From 106f0629215ee6c69e68b528dbd66ba22d4e4848 Mon Sep 17 00:00:00 2001 From: yang Date: Tue, 18 Dec 2012 16:33:59 +0800 Subject: [PATCH] add notes and image for doxygen --- doc/FunctionList.txt | 89 -- {tools => doc}/doxygen/doxygen.cfg | 2 +- doc/doxygen/image/CFFT.gif | Bin 0 -> 3482 bytes doc/doxygen/image/FIR.gif | Bin 0 -> 9671 bytes doc/doxygen/image/FIRDecimator.gif | Bin 0 -> 2816 bytes doc/doxygen/image/FIRInterpolator.gif | Bin 0 -> 2700 bytes doc/doxygen/image/FIRLattice.gif | Bin 0 -> 10034 bytes doc/doxygen/image/FIRSparse.gif | Bin 0 -> 9952 bytes doc/doxygen/image/IIRLattice.gif | Bin 0 -> 13216 bytes doc/doxygen/image/RFFT.gif | Bin 0 -> 1932 bytes doc/doxygen/image/RIFFT.gif | Bin 0 -> 1939 bytes doc/doxygen/image/ne10_library.png | Bin 0 -> 18463 bytes doc/doxygen/image/ne10_logo.png | Bin 0 -> 12179 bytes inc/NE10.h | 53 +- inc/NE10_dsp.h | 459 +++--- inc/NE10_init.h | 30 +- inc/NE10_math.h | 2582 ++++++++++++++++++--------------- inc/NE10_types.h | 112 +- modules/dsp/NE10_cfft.c | 165 ++- modules/dsp/NE10_fir.c | 334 ++++- modules/dsp/NE10_iir.c | 11 +- modules/dsp/NE10_rfft.c | 96 +- modules/dsp/NE10_rfft.neon.c | 18 +- modules/math/NE10_add.c | 1 + samples/NE10_test.c | 54 +- 25 files changed, 2440 insertions(+), 1566 deletions(-) delete mode 100644 doc/FunctionList.txt rename {tools => doc}/doxygen/doxygen.cfg (99%) create mode 100755 doc/doxygen/image/CFFT.gif create mode 100755 doc/doxygen/image/FIR.gif create mode 100755 doc/doxygen/image/FIRDecimator.gif create mode 100755 doc/doxygen/image/FIRInterpolator.gif create mode 100755 doc/doxygen/image/FIRLattice.gif create mode 100755 doc/doxygen/image/FIRSparse.gif create mode 100755 doc/doxygen/image/IIRLattice.gif create mode 100755 doc/doxygen/image/RFFT.gif create mode 100755 doc/doxygen/image/RIFFT.gif create mode 100644 doc/doxygen/image/ne10_library.png create mode 100644 doc/doxygen/image/ne10_logo.png diff --git a/doc/FunctionList.txt b/doc/FunctionList.txt deleted file mode 100644 index c8845d6..0000000 --- a/doc/FunctionList.txt +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright 2012 ARM Limited - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * * Neither the name of ARM Limited nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY ARM LIMITED AND CONTRIBUTORS "AS IS" AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL ARM LIMITED BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/* - * NE10 Library : FunctionList.txt - */ - -UPDATE HISTORY -============== -----UPDATED ON: 30 / NOV / 2012 -----UPDATED ON: 10 / APR / 2012 - -Overview -========= - -This file lists currently available functions in Ne10. - -math module -============ - a) Vector Arithmetic - - abs (float, vec2f, vec3f, vec4f) - addc (float, vec2f, vec3f, vec4f) - add (float, vec2f, vec3f, vec4f) - cross (vec3f) - divc (float, vec2f, vec3f, vec4f) - div (float, vec2f, vec3f, vec4f) - dot (vec2f, vec3f, vec4f) - len (vec2f, vec3f, vec4f) - mlac (float, vec2f, vec3f, vec4f) - mla (float, vec2f, vec3f, vec4f) - mulc (float, vec2f, vec3f, vec4f) - mul (float, vec2f, vec3f, vec4f) - normalize (vec2f, vec3f, vec4f) - rsbc (float, vec2f, vec3f, vec4f) - setc (float, vec2f, vec3f, vec4f) - subc (float, vec2f, vec3f, vec4f) - sub (float, vec2f, vec3f, vec4f) - - b) Matrix operations: - - addmat (2x2f, 3x3f, 4x4f) - detmat (2x2f, 3x3f, 4x4f) - identitymat (2x2f, 3x3f, 4x4f) - invmat (2x2f, 3x3f, 4x4f) - mulcmatvec (2x2f, 3x3f, 4x4f) - mulmat (2x2f, 3x3f, 4x4f) - submat (2x2f, 3x3f, 4x4f) - transmat (2x2f, 3x3f, 4x4f) - -dsp module -=========== - a) FFT - - cfft (16, 64, 256, 1024 points) - rfft (128, 512 points) - - b) Filter - - fir - fir decimate - fir interpolat - fir lattice - fir sparse - iir lattice diff --git a/tools/doxygen/doxygen.cfg b/doc/doxygen/doxygen.cfg similarity index 99% rename from tools/doxygen/doxygen.cfg rename to doc/doxygen/doxygen.cfg index 8d886fa..d34569d 100644 --- a/tools/doxygen/doxygen.cfg +++ b/doc/doxygen/doxygen.cfg @@ -858,7 +858,7 @@ GENERATE_HTML = YES # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. -HTML_OUTPUT = html +HTML_OUTPUT = ./documentation # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank diff --git a/doc/doxygen/image/CFFT.gif b/doc/doxygen/image/CFFT.gif new file mode 100755 index 0000000000000000000000000000000000000000..1dd540c5232239f7975ea7d3ccf6803dacafabdf GIT binary patch literal 3482 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 M=kLNv7VyWv05H0e3;+NC literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/FIR.gif b/doc/doxygen/image/FIR.gif new file mode 100755 index 0000000000000000000000000000000000000000..2e0d1fceac420efa0ce8fccf2d0170fe0e79f070 GIT binary patch literal 9671 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 I2LLGjAOB8P=Kufz literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/FIRDecimator.gif b/doc/doxygen/image/FIRDecimator.gif new file mode 100755 index 0000000000000000000000000000000000000000..0229d31a608195497a9f8984c6a75155e6f0424a GIT binary patch literal 2816 zcmeH``!~~n9LGPo%n%V>+*XZFXtE^cQn~ciF4CeKxs^>WwUn;Z*+;E35xLFX8XGoY z2$2k@zBU{6EhUR4=90^Ih)Uu+{($fK{`@^X&Uw9F@ArA1^M1e2^E{siFm5QjQ+rks zfp5Sv;7Wlj1C;MTkSFIOk0p@FPqehOw6(QiFc=&TM<5WEmX_Am)+iLp!NCEG#o}? z`T3=#CHb#@^IL)csKC-s8J%7zx8kyImVg!e$lLNt&XylaEB7Fl`*J2?JZg>AGREehxr`V0H|`4i*v2jRGjX$PoFS&N zke_1e#rEY_GTUj$AVChMiY3ZMMSl6nuPW-yce<@+gsm=qU4Tw8_Y+i?yeYyLU~{og z*j=0xRbjn?C!F`?fvs^yxSG-rRUvQKe(g1n#kCOwf?Ql}S#QI&*De6Bw)|5QsHhHe z-`FB*r08t-M|4N{CjcaLp8L~EX?w=5a7e_i%AroWYtYaFs^HA)Vz0!>()uT328Fl) z$6xhx!`;@Q;=XfwwP)k%udBz3qUtVuZnA*v^B30&r9wZ4Lz>!Am%84Z@@aZt?=X8; z{B$vPZqn-6ck!o~{PX@dZiY{f>SSFd>+Nm-@pZd6@w^s!k^i$~FrTo|P~s0RXjn_g zP)4;x$;>b#@bVJ#odmPSt*-CRfGcLIXOM3gEF6f|3+yTNxH%--`5PN%mfy+VjA0{D(ee9SwibaxU zT40pcDK!|{EjR;KEbB|lCwl8aPy5VCS6h;(Nn~?C!ppmnJ{qH#d>sIlC|C)P-pwt^ z%udCCrbIItb12dAi$sCOklKY3$q+SDA{+p2-9dQAnT5rB3>7OP@#!%Ii`lno2!F6h zTU%5RhLmjp*W=x&Mw90ds8m>aDZK2Lw78#0u}6L(XhM6&f-Q_VY3c@N!EomW5B2e) zW-R2kqP}j!+L|6XhhCYf&0fU~wx@^Y4hJ_(97Per%j+A$w1%ph7OAX9kN@I$KA-Pv za7|9r?or?*6O)>srB+g8&ySC0N0c?J$A&=iAnf71s4#p*vw3Lz&envrW2FSmYNx4d zJ4$lOFk8AyXF43ejYqburrYcyt|CV%LI-QEGlvKG z#O!->a$xHb!)`|fjb8s_)gpm+ zk3|3A6U9r6_+*KGz6HMbNUOm)p{*?UL+Lu_vhu+rFJyN8DF%}hJxK~c<-j&-p2Y|g z*H}tCda|*IkX8ONdCY+4(WTm$@|?t)hQlrr^>hQKu)Loz2X@u*W6sLSdwhe31aE|% zGc8`s+p4{5{x*)e5U@x>~UCSY|%~YrAk7Sp1Jr#HQXU$F#2~a@)9g<=j-=S`6Mc0{o z6^mAat43yIY3fhi+u#n5Oo!@q;U!eOkfA$kyubaKWdC;E{*6yVvUb)Z6A-CzgPn{Q z1Hy+pE?ajPr46_N&D@Ba`#T^%>kd2}ynwoM?8CJeOwMl}U5}Z(o2=_I zxXB{azN{yZ`(& zjklVGjKv5~>(6AgxwEWjd||NtOy;Y2mUR(E6y`IN)h%S%)bd57sF`fZ0@?`x9R2~6 CHB2S| literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/FIRInterpolator.gif b/doc/doxygen/image/FIRInterpolator.gif new file mode 100755 index 0000000000000000000000000000000000000000..ee83141742152d8e97074ca6e275bffb4d40e727 GIT binary patch literal 2700 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 Z_UrR^&=;%hFV;j}yjL(wLLfkD{|AxPknjKi literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/FIRSparse.gif b/doc/doxygen/image/FIRSparse.gif new file mode 100755 index 0000000000000000000000000000000000000000..bc05c4f7a25470f18faabccdec7d27f84f9d0c09 GIT binary patch literal 9952 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≫&dv)ub=w(ZK7f|_-yaBv55yjJiXY(f*=D6 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 Ozlq_f2|N@EkpDjna?}X` literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/IIRLattice.gif b/doc/doxygen/image/IIRLattice.gif new file mode 100755 index 0000000000000000000000000000000000000000..356152babd7edfa9f38da201630ca80653445104 GIT binary patch literal 13216 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 literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/RIFFT.gif b/doc/doxygen/image/RIFFT.gif new file mode 100755 index 0000000000000000000000000000000000000000..0d9322d4be88f54073ee1cfa0b280f178cbb9311 GIT binary patch literal 1939 zcmaKrc~H~W7ROIp*VZS}7L;HVv53Y>OQS5oQEZVV7@#PGB_JyPs%+IVxLbmV2E;JN z$14FM0ueAF1o%NfKoBg7@Do`o0V7&LQkH@UB3h91f}QDKZ{D3VckZ3JGk3n9^Epl~ zjyAS?1RrdHNr1;w)9`-%bNKuE_b!!6RVr0OLxV=686F-+L?!?SfB@hFhyh3d3P1~h zx}wvO#X>F@qoPnGLZuQZim4B5BM35qqiaF<6-ce2atpLMLO%!43oy(S&p4o%z(N7u zkzqH*GzGRL1lhw;cMt}GGy*D5Lt7&Brvb_UOHHxX0Vx920_>IH2*qTAlN0cGaOe=k z#erB13I){FK}QD+4FRIA)**T#ore^MtxLOfDQ?(+4i4z=kB1MVK!6z;SX!#n0cpTo0~{t0_Q2|@P%L|{~KJw8?p2kq7iB0GgE>A2k z?rXZ_WyDOiM_O!el^ESTu*OLJQBlBqavXhY)9w=sR?57UOd$MWyxeUgx>(^!!48gAaf*CX8Y^7O3Xu(Cs ziIBkjf&&N7Zfs@m=9lL*%8PT?O!eovUYBJS-gdKlR+@XTbEvpFqA7guEx!xFr2?Z1 z3fHWezZAte5t@RMbK)Vx8$DO-Ru#8ykz2^pE)Is54YJt^#aoL{25KwEWTU)=pM)uc zv+f(Ox^meuU6DEUVHKm0GW>FXzTwvVR&Te5j)%kik`pbfUYuD^uN>_N^=zET+&|8J zb?4-Gv%d>NQf)tfk;Uz9Z-&7G=N}kj4m^WYGIMQv)$a=0`Kj?xy0yUIzH6*`f4%#Z z*Gn}+lUh^lbaGg3Zs%Oqc?g}3 z6;E3{3L_USeXM$RUM+c3bi6`-TsE`C_E2A2K*5uq)aa?OUZ2TH+y40Y>Ok#KM8w3C zUp<>o^cPI3%I_vk3ZtIil1EGpEB**v`RC4$w^+aYg{EgY=EiujaXgoWnR!Csn_DV>~e<9%RAiF@NJX+Dm3vb2<~d@b4{_>enslrPBf-i{_yB|7jt!U`nI^m zW`4V#xn;N{e+VJ3R<~XIKGZ78@8O_V{zsYYKDH>NBi6rCSpUZ0Pv4S*#tCMcBU!$s zVcpGf@{W;!k`G>u^l8*DcHfGbtG9+)`eSWfyunw*^yKKihD&DdIlQjoRzBGM7t4*& A;s5{u literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/ne10_library.png b/doc/doxygen/image/ne10_library.png new file mode 100644 index 0000000000000000000000000000000000000000..e6f5282a55086c010c6646e7ea9b74447c03c4d2 GIT binary patch literal 18463 zcmeIaWmuG5xGxSUpolcmAxKC{4-HaENr$9#!vIne!UzsEh%^i>jUe5n14v7!fP<8D zOP^;@-`Bm*zRrK2>pCC)ANB_?Wae4Vy4St#_}#yCFGAH+6>j5D;-I0S-G2N?Rs#(U z;}8uE-Tejz@JT1}4`JX3x|@c=L$s29>Q&&E>(dP)4Nal)v8=R~m+?lb^NQo7{v0*~`Im>j&v;k)!EaZqwD+vDcm};xVqStV zre>zK_|)w>VRy3y+4|l^M7q3pNrAo!^|B|;xrs~2Q3fW+(s>q^pZUNtNX>%s*{q81 za`>s4@zmCLQNQx?vDwpNzy7Dzm%{0vzU`iF%uNmWjCrOvw50D9R~D-!!KgOej`KFx5=8abAMN*CP{I(U31e zz+|!~tz5-!UK2K(V)obQilXDnl zNEQ5L*fH$$LES>l8$ObsKdbIAA!p882X4tWFOvB;yrxM`*FdN%{7_9jT!AIBx~QQO zVDrfb(gF@d->-Y0zQR*F2LXfRt!7ifE4Z2T8Ttp4Dj0G2)zJ{E&zupmz~hKxHcZ1t z?_>Nk`_x)Yk(1-J^m_d?1SXR@ruwx6scwDF_nzu}r9R&0opibtZBxpjAUkT&+@_-N z6;(&9uX58y*M|%uD~d_RpxKggWc_XrGH!{PGchf%@-t(tU`01(&lm@5j)V>^>&)E=78JRavAr-xBId{OXlVKaiPjj0eJt6+v# zHP{lUV?35Eh|bl`XUE5clznR#AFSB(G#VnU*u*OCtgQP)!Pj1Z_2Yf4u4V&WG(=m3 zdd6#1ECME7?^`W2fXL~jgbH)idHJk9CwXqx!NS$wT@uMFCF{3Bk4$VT-wd*i;5HXv z!N04LVHh5BSGAu0{(lcIrrCa8FTjY9_;t4SHY zJ+A2=Z@V*D_rf7bwLX@G`Q?z0e6iw=RziR{6lBgnfByj^Yf|()!zMZs9~|OJmt~ywp%NwbV4~2*0W0va>*s z1ih|Pa>pd-?(~W+sSt*O%0A}qD;1G2QZ@uUsTN=AsWi&CHt9ejdy;b-x&J}P4A_Nh z$i@t*`bK$GYG>zxcx0|X;(lX#TNt7BHl9CNUy})mOQdZpY>cz8-*{2edr6N}CeYR) zE|jHS)GtxE!2Z z_QpX=NkeZTa$ky?sT4OZ;wHxkZ6k9_9GJ+O{qKA-z&=m;X+GlZ1*I-q@Uw`!{qwTg zbx(!O(j?SLD|C78#>L6Q^upa-ve@LcOxn8|1xs$Qld(Cr$8}X?{+orQ;LFaBt)UbK zj6~!9dC=@bOU$fc*M(gTZfm3xym892c;6NA6kgX8*^^XD;#XO$_ehKDG0c9KN`xs> zu<$SU-os#3jwKEX46?-{Tltx_<36Zt$e-4x)do4;=`s4(%8~=TJrSO5! zPOwal+4%Bk9*5S%N_&>bYS>A3m-UMwIzis+CPHFhUUS^$`=dHB?*ygiTf?bhfb(xr+sO1Mpxc12ayq2FfD< zOSUORWu4w~2Fl+)pV!o+{t0Esh}Ca;2-!e=)F4#-fqJPFTwh1_PpYb{5wat{f_~!E z;fbsdlu&~JH_K>3fdsyuFq>Z`jTHRwQ2zEcR6xmlZ4LwuD%_?z+|HZ~ADo70wK&!|Tw#BM9~4T~a) z7Gvx1PIs4|akids@c@hZXa7{m5XT3X7oDCXO%~g`_jVlycbnSoH+`LK&C_>Q)AI9S za!TEDEJYDzq6?{Yv2xC=iZC_{ge_CH&#t^MLMIed0rRpPpLUcdwZ6j_2ug7H6w#E9 zLEleFsGwSE_N0R$XS$AFYc(jX_Wm*?ch&B}ZKimq(!fw#1W$BCw9ZIVuELMvEEN@< zxFG>)csE4AOG=!-37;W@lG-6#U7^($lg*757X$E?bKmgKtZG2{R>6fh&bizzaIcH7 z_Tar0{W?@@y@9LOCTy7=KQbw4Ig~#tzAaE!S;6;GU}LKF-M*b^77@6Sx68RN*S3`0 zDn4{Nzln0iWRXrOyphMqmE>^;u95Jd;9XNDq~2?gaT_e8XWulZNmS^5fef9@7cQsl zllV^^l*~~=MW5&miJm@LnWNr^MO0f-pKEXzl-k_U*$fVlaZ z*kgsJC3llO=Fp=K*86x1Et-*)B`asv*}l@`#QKT(WJI>THTh#zQ4=QQtE!&RjWNYf zpKvc#6V}NYhqO{1O|!Tch?2ZHwe%4hQIKgqER7ThW<|s+xIv+wi=N1{<+#-j*q7lr z^5x>l=1mS*m0*aP-BMdFgI6L`l5mdN^9OW(VU6YmXY}+i8c$SET{e)F4^#wD2dI?7exivsb|0!);&b?* zg7l$rIZ%n3e4C8cRvsoN%d+H<>)z$3u)wi!RMa7-UZ+P=i{*lMQe!JeXdm8#XU0`2 z-o5X|^?jG}kb{m!Wlu$9VwcbA@o-_W2gi^KZ;vtMVNfP&W z87w(3wxS7H_FVU1#)?z!&XTio75vOAqbuFLL2>>1%{ofLEmobJd&|P*(q=s&6mf6g z3iBdD?G)^`OZ2FfFGvvgA=ZjmNDBd?#ruTi+4E1IGXK;I=1`h`po`VJOX0wrdGGmR zUQZ_m;Ik*kccRrZGytkh4yswMRDEZ{N~d1yr)OP>*@xMTtxe;{l*KXc+ts=CcUn2I zOV>&=U*+>(f0`r7`cP$wM^mT7vp|~qnwg^Ntn0SffhK`9#)w!Lk$&#lGbYXW90`Tb zLx-j2MbSuT=cwab%duXqctIezYb6u(sb!#?<&c2oj^jJYL~=W+yA@dp2hW|k1kwCm2cE0vKHj~4P;kp{9~x-%gKCL54Pt6zhv&)SZ_H8o|yoy`!K#8NgF zy*5MtJjry1w3Y7NNt@tX`cC?B>?uy{6}!nqQSJ`U`%R_uIqYd1mS$9?;d*%MN%xzY zHoaW33fEaj6`zYf$2y~(71=j5b|ExkHFfxl)*hgnUm=N5!iLh0UU>(l$CS|z|(rE`j?@P|x=Bd78 zO$qMC8FL@yyeQlpy0yDjI&}@mz5dN|79{yvXoyK7WbF-}S`XQ{n@LFewuzDsos^EO z$W=DL>K$_2rrG-S9GSl?uY?wo7iZi}sZ9QGrb&>e#bK}@76LL~D^WEJ=lk4ABxbeN z_>f(bF-!`(6dpx`(%HXjcm)FQC@t{|u9vmH^GN;BfeZ1)PIeFOPRz#l-~p>>+Qpdb zp5q3!lOqwx6-|Q9_7r_x>GUAbl#r<2B#lolVcxsQ+RMI~D$q`BrSjgohA&;g+gEII zXke>o75*i3JP7mAh~^Wc1`idwN9SJ#Fhd*70hi#st4d=2T?m|0vxQMy(b{&3yl#zf zhd8ID^hre~>3>mnr_r6Oe2=^ynR6=;;yh%@Gi(nY(P&On8IU8i{PGz)x+jQLt4`;s zK}Vs<-2{)QKtxC43rZPy?WGDe$2mb1hYDt?p%a{|Gj!IxPxFHoG+jg0n=cKrX9(no zGCXKZokMHn#hUp37nuR^qZycEV&;J+pmK8L^+g1cR_R2({?c2Cn6_d5S)m3TKjf*8 zU71rZr+7S7r<{2Iu=AwL;g>Hr5usW=$an}HqTFT2ee^x4l1b*-yh!Fg*QirQfTj<* z3_LMTiFCUeMx3Y-3ZjIabiX=~!rHn=LHFTNgMYlDA1VQYo8vzAUBegK?&TYxCVSna zCI#R!>xa~SQBPWStWAPCFGR||I%L-PCsv_NlJ$6*w5fP^Roau9_xOxR)O)nBnd5TF zsCKRhR&f1P+#6};veJ7)zExTHLzQt;t(NiSuZT)`JV3KwnKY~ z`ymYSoKQ02p>rgINO>Yp{`xq_#x98V3{7tt)NMPC9WJD-)yF`^T&O{X<@ECH(v?_n zALk59XG}vJ5ie2rtnIp}gf?8i*zFs!cB_h;Jxj(Fpgp79^)o1SjyB{gt#PLDi9+EA zJHtD*1?r)K3Re)3ED+?sYcqqi92+rqrkt?!MFGreruikCX{$~j6gFID08&3;QOKI^ zw{;?kem+*<35vbD^SQH`w%%DN80mH&x?ov1;tT-jZE#u#S@|98TH(PDlYS+?zjdRv z&m&`(0x~$&1}*qyO5LpTDT;{z#{P!h)CMFj!-&G0uJ9``3m|2SE2LZ*l)`>_c`y&b zSN%CNTBQ4Rd#Nv_bMhPU6EQ+jiR14vFb_l4!>3oL2*1%RTuC0T<6@pdV*OKahPZWS zy<$MVf{|ePaASJB)P(F_4wUcff+7c;Kle&Szu`N)M;2b~62kzy$;?^#Zq{RM?7dfU zHz71TIno0ge2A_5FI`PlN(X6q>HZ>B%IAeG^Qmw(OE z6;JQ1Tg?HI&A+IBQV0phcH%|s1f{%vkX5hA08{H&q=!KGA;W_iUvT)ZDw)bn)jaiD%>D$zlm4Z{oO!)DTm2z)p z2T{r3cU@;q2d&_kiG{}WY3EdES(0`(*ptGzt9fy~f3P(@waW_AoOK{TtlnmFT!8#* zebq3K{mT?0aCsfuxVafuK`|0Bs?lr@8@m3UplY{=Oc^bjo65RhyPSz4us$_EFlP#*iD<6l+^X(1}}obAldwp z;!bcCC=T(V4yb^ke@ep&PJ}+o3@!sq@We^zLZ}I8O90lua+MOg1{UmOSGb1@V8Gv{ z(@2b;6Fv|SSV;Z zC?!NkA;0J9^WSxOg&+dmiEDU)+jrz|1<;~Comt}c{`r@~3DD!YxOHvzPh1tke@u!a z9MpOn3viQuvF1VHH5AS8iSG0|7H~}Y03iA*NRVhkdZIY5Ftor+>OiEa%9e@*9zG_- zu5FuArw6hOIyf=^;Z^y)EK5C)Wv>t@jj}z!nnrzl^7@*A0MQQtCK-ca5dR&nd>HXu zfY-JDd3vKkqHVIfN?Hx|uG-A7 z3SB-cL)3}v5<@?>#CD+lc*)nD#qr4EE zQ)IwTw)rJlK66hJR#XI~=Au-%(xCv9vGzDbsQIgl+g8(&MjZv;D$8r*Cz9vxIR*Ax zDJK43>z^x0;&0~IK$^r(*DK&nJdERPi`UsGtXlo3d)LZA_g~eDVm1Z!gJ#*nb=2V zP2}VEONpV`O|ruMfvbhd3sq@?zZ~OGH^x-f4N!G27xp*Q;7IMjXbtet{}`X7H(EJLBMVP_q)0}#w!E+5ViK6sRnQjR+ex5c z`tDGbKJ~`hMjyf%IAhX$ju93^;wdz1(v*1w-Fz|d0(+~bt)q$U!7ZnJPo|_#5_DcU!x6PjphW#Qoo`t z1hMFVeT5{W-z?ZX|4@?O?Sz%+K^PuwzJUj=pyjenym=K%{jMB_U|DupM6aDE# zk9KUoewABGh`fCR{%$(iBuF&IOTk{g+#d+0hg34sSwQo)MB3twK+<(bC zU&ZBNh^ZAe4!*D2{cg21C-S#&iO`x6p@60X!gJC-CCTe@}jKeX) zug24>n*7>LeZ=ev$^UMH|L3`X`GHU%DBz&I<@{Xogs+Lk<+~}wCpKyG5qM_YMBvzAjOT}jy7=zdE@>ovQ&c3gA^XbU}fxm zHcZN`tf#6)50%D&RS+8}LJXUH1SI%Y@pYTe>iy48fHEk$dR$&Wlxh*wlp^FTNasbN z2BC~)h{-WwwjQhQlDcw`wxj%T2lk~90v0PMR$h^60n+z`FP%8I_8wmdC^w1dLt{9D zdrk~3ucT8jbJtNkFlIRbRSA%5|5p{ys#(Tfn#_3lvs>7Ib(btT(r3;N$N(^Lk^ zh;tm8ex?t3R5#*@3+6w%$2HjOW6z}0g;Ur)5yro>&k}GE8=V6ONCAqxcL6DCkH+ay zYhfc);4+pUGmN__qgN4oJKZg-TO02Fp>H$|@3ZWvm>~#R4{7(TTie*W*zS}ld(Vb3 z$yL-^O`vdn-Zk9iUUnc6_?5Ji0~>Gliiz}-`cfPDKC^}ENL()K!`)PsUhP0opUOA^ z9~AUMDR!Y;MOinsE^OGhkrnCw@3#PP+=hmss(wd{N)~xus+3N8L`v-6&3S=TkxqRD>MnH+c27TG$y6Y_S0u z)}}xvT6H7CY7*o!=&=Z1pCU)5C%{lfMxix?56wA&{hP(%li~St(wg!87+$T@8$?P0 z`w%sH#t#m4WelfEA192>pv7%^5(R3297Fe~m2sSv89QT5k}KZ2Uzo?dJlG-4q%LPz zdoUV61hc>LXuyN2p`c%LYn2P%cZ)E9eXYd@0?m&NJ4&z?`2%)x#jJdDvj@ZZDt8dW z20oU-*A>Dam$}|A^AmY~UM4t28=j%P;qsO%@&@;el9toHj7~V^2mnlX6djM4;>>QW zPRP*pyg334NnK`G2$26@HNibZhq}W8s{Xa=}xBa|7 z8`qflQRh4_tC97q}m58`{z|~ zDe6+j{*ZMdIq$U=*M^$wv=lx=yHD!h$x9fS#nkt^WWsCMq8=%ic!w#-JR;mMCGA{% zQ>Ob=jY5feS|T^GZrhYJPwYA*`H^y|j;hIK{aPgPRYC?U1PBidQOdHWGi4_S0=Li zHL}Ox4D7j}sk&n@S3`$H)Kfg>uiowWQQ#j_rpl25;LJ9kC*Jh2FK51nzfeXi8}i=H zcccWrd#tipaNJ3X%7g$!a-ad5)dO2E{=IE^aXpJIdtfHKW3*?Uuh89@R&E;McgcT! zGkka^>*TJgGGD<8GCU2>_!9?f*Di(OIImv(myVnJp+zOkX(gjK!D6p?Ye>-j^eTLw zEXwNjeK*>RQn?O*5)_hYuUDFed%gtm7{z@}=B6#WpRpsSy+dDES97sP1h1uw;vV7U zT&)Vl)(QlPM-;LnuTRz{xT{2PgW0xHvrkl>I(3~*qxYC8*SqWTkk%OnET}CjP%j(8 zMm+IF{5bm)ndOz+pV0A)oiSejo!P2`KpzuAhr$!hw<)v>%e@%7xUrMwQ}lGis-X%N zF<2ygj==ykw{$@g9KT8dubews>{vaE)xF3CoBd!jhpnGvl*>jNz1>K(t!QJ9@J*3! zV&uJBbXA+0+lu!=`x}|V?&nGh0VRLD zkBMGYMsdQOm0;P1opO3`SOkJ^Kt9u6^`Zlx%K4@kGh_bzT=>@oazrVv116WS5?=S`UR*A ziW@5XC=iqURlSO|2wNDa>6%YmFaN{#9I1-8>Qx=0unp4NY+K=cMMuL_1F2+1t2`lM zN7b(d+OVflNC=8TY1Vg`9O`+XZk42*RSN(K9It2W1EX47sNFA~Go00$uKPbrJ=_frg#eVoFRVUS%~0NML*JiUV5zfKY{h|2rs)gL0%{);dRWXzgjC$m=dlZ`(d?%UX|UN0q?3M7Nx(lJ8N8y zZdhPJ70!yc*x=*|B5AdZxPKvilHAP{CtPHuD>Kmd0JM0aYKOL(_fQ8ON@#_xT~eGF zbQlqTBM1Z4w0QL`Ko@ZUc4khH7sp44jhXxh6#qv}syKwwvwl(h7en`Ey;2dv0-yph z&@ghvP5<$k+y9u7nbLLXK%IY~{BI)}?oI+Y@jvSR6;Pz%Dw;jT-%;R9mVm_OcQ**C znz2&SAVJ!kec$Fcwaa$m2)H^5B(->BQUY;#D^ z`oFQSiVI>t=OF;!)AW2zCu+W@qtXAoK18RP*8k_T$fHT?bR)qgzWtJCc0WZBsV7%B z3F|*uCw}%@%vo?Jjga%~I-&1mqHc-d;Fk`7XVs8@~QCK8iD7J8^5yz&@c1L zdTHgWULXiN#g0e0DOzyEb--Ha-Y2Vh6(vS@lKNQ`Sp@p* zLUe|0DS^XClD=TLt2+*_V0|~WU2wjY{6cn){q`Di`u=JIl`T)9bnKdLYS=F`yl)J00}d_QS1qC0uo3#h_qIS$H%VTxKz{IES=;%N4dMOO zv-#L^tMM}BV)V85IP3Q9xwCrDv-y^v1((}Ojog}n*#3ueEvE_rGh0V~^AG`s#*=Qz z^Unci6M2$*!m|y!^CvC7bK@=RbWO-6NliE2$J349pF1CaR*=wGI3k;{!UdNfR15YL z%SP)jB>M2I5%Q>9vwShm7i0^cp8sl(SMpY8d!C%i?J#UqPSxCjV>AC9&ju3tdN?Jc zjC=`UWLGYku{60Ie_S|9ec=Jgbd#T?!l@}m=^7z+N z$5KD>t#IvmDie?8qRqP9dzFpi&H7FV=;%?eo+zPln4S8@M2P|Hx(=fV?>yhL0^Pg zvdd@fTN-!mc6EsAv=hQ&$&@24UZBwl+4%?X#>)|xNEX;v39@k3S1O-`%0FLsVD z_m^9?g#@yHCgGo-0i?Ix*#*XQr5t?Shkao1vyG-&VmL@Xr)_*c@^ogEAFG|vIS4fD z*KRR4;Zn|!7YEP-1pB%h4p_ zJScIGPIqzR6k|$0CH!7t;NTuTtj@xWh%F^w1R1LSmZ^k~&M@g67uGcOYf#!tDuh5G z=m9YfHPB00@%$&q`T`?$t6>YBqm?+eZ7C}*QES2ug3Bxn=<|7{$ z{@A`z1yRoU5&R|3uqFjoc@yc?)r0V%*L~X&zv5G`l4N6C(CErmexQNW^H?yc$c}%m zKD-1%bm_>(z2#MZ-q@A8NAlRj9^l>erwR1~Bm%Zs0-k*tTod0qACv|TMB?S(dJv*9 z&<&Z@COx=IqK^)7m?bOIJpl#y{9D|-^64M>CdAtD8XZhdnn9eRo!_T$FodUegZ z^SRp80^w^RNE|y%Ap*Fo30&h%DCxsZ)ys}rvo7_gUw0k}yxLFutj~0ROscR6{f zbGOs_S)2z#oR;xQ5|^@Pojo;KU4>-Lp{ljH6bvc(u2bO4InxYWNQeBmMOJqk<0$`Y zSFFC{&h2xzF%J8Mdk4-s1>HUz-<;Jpl#{XvJ4rL#b1M7=Lr^>(4mGO9O>!M{3FX&~ z3j~^313|l-N%}gTgYmA$%=Wp7cG;1W^;)A3t}`{;JPO!N4I(v>Ot|%WaSb+qy+dcO zHf%oeB-0h$mD2km`lYQ4$ExuUepiCrh`wmshIFTITG%N!x3VHDDI2&rv|SxWh8;Ox zAn2$TCOl|FO)g7sNWkd(qh~!X_UOe+fJ;x-!Pu7B_bJ>fiS$iGwvIdJd=Zu$*ecOj z3hWvBdAt4mVM{oj^HpLBN9`~-Qi2_5B$l)A3WLt|M#w4BVgKyW6pCx)U^s<|jz+q< zpTf!f`o=$l<_@cCR7zD-*REGeK1Cn+7&{u?M%tio^byv1|3NiJK_i3@Dx;2#X$1^k zPZYdEJ@rIvpKtEKXzl<>CTTK=?hdPHs(#V_(Sp>$BHzbWsrZNEG}$0bjsA}Nnn57G z8pmD5bT}rm_d^Zlz)SZgA^?=eQA1O6zEy!tPKFX_y}w5%G=68opdlPU-Lqs=JzpPE z40I4E(p{o$d{n5tg-FuLFvQ&y7@TB7^;Ad)QUGXB)I2;6m&M5G%roG~^CJzUzv*c9 z)(VHsVOjF%t*4!7LUpDgWV6pXu()-T4JZh#Lz>=ycX&j33t&1qSTA4=T&4LK?p!mC z6#iEL_s{zHfb~ttEudO#vZEw?mQy_ov)qopdIs#qq&v9IvfRKi1i0^h+!qGhxR1u! z0n%E(D{w-ea`>nn-JJ^&MPcQ31=xS7D}qyp7oKczN#U;56B-7q=C8Sqk=2?8pk}Ly zX~q7KcV!vC%Yu+wwQH1!n+t>PancIJdO@^O)=%Pl^?tFktPfB(M?2wV^Ixp)!o<zV!3s)GOBoVk+RKZuR*X06}r%pe5 zzC{gzZRTEEptXa|ugbz4#FxP=p0> z-Z(f7*tcGUt#Sn%kC3tSXAk^;@_b-V2<|m1ZqC6#za2BtVLYYV8l7f0Y*a3p)8}3i zl?ch#N^4#uPzAlPU2yjQ;o0d*?!evB)!Pxx0*GJ>nWW6Vu2U#^C1oCg= z-59VB-db($K6z<$vPgxfqXxvFEy|6!t9mHieIaV0P3=c=u75y=7NCPEeuCR+&7GYE zAj`Tykh$RAuXeURg>Qk_v}o=+Yn}JTfa^QUmi3?@bF9dt$-ABkcKx7LNhuF)&Z>0Zz60 zAn|>6L208h;4|q=J0dv~S3j3fL0GgVwpR*%OPX3H0(LR)KDr8BxKx4ong=iJ!I@1F zNhwso!K+Zf`FOzlhp@W6i_rnD84e>x=Z~g5;KK_*T5%!c#nwAzfPzoG^*yi`G-(#M_s$h)`!dY_ciq zR~z`>XJ+td8w7+_D(_hL#`EivW@HO(3xRwYMq#hsT zH*D0gRQT}`UXUC~5_9vNgk>;6US`b(KKLF?$Nje1c_@_l9q;>qv#9VB%X)J^r`u7x z$1eyKo5pnRV>bp7m}++jUR#F$Iix#q=N^vII}Uc^i4jZuUJ z#_QLh2?Q-Vd~8$BN5bbYrwL_F3#L);v3vk(k{n5s`Qi;5~t(; z;f$&;`x&FevapTnva%ISHYU!R-wc!C&jayNX6ZVC2au?g4uABZZ@ZNfa}nu>3aqF_2fphGe7 z62pOA{*{&0w3q!%8Lh^hUcdyz%I2i7ecqU|DiE>I$g%3*d4Rs z9K&d9&epCEVi@DEA3O-z>zv_1KI(O-{~?Q@I7@rr^_ka&&M?pSLCszOIptw38$zFI z#m4(fU#b7?lO3Qet+1Nno#3?>tUg;Adv9Q?bncVpf22qi9&XtAQm$X| zGOOE}*!bCPG*riS4!;wI7Zj{oP;xEuYf;~_;i%WpXYA5^wt*3BKH-UsZ<7JqnTL^} z)z~*q8omt3*jvZg_?BlvxLkA%B<#6ESZ)TR%N9<&?6PpQR0TS}{eICcU;p;mU+GV* zMLm>ns5Ap$2Pk^Kb+M%PHW%3Sm@3IVGGMzfttiqh&F$M?^F9%8`6#-%0|?nfqw1{~ zrXYey&n?ZTG^{b$By!W1sL0!s6__D-QjzR+JvWtJM~*rWG+dR{eVW=U-s7BgzDdZE z`^wO4L{ywhfNrq-95FnZ^&p80Ng)GYoe|tQrciRNf|~EW*sNQ=bDajrj5mf}*pNkn zBut)scqmB27YX9^uX*xhY>}(1RX8PQsIGKKa%ijE+#(*fb^{T5N`o&UQ16dnHeAA& zcm_p8mSN{`peN>huW8B`86v`Cq`g$Via*^=$bv~T>YA0sxWDSC9)^#E zOMh?j0M|h^HRT2x&*tA>0*rY>h07AL`c~Ic3L7Cyb5Eh)59%q}sAZ1jajW<3papYLSI7;{NtIhs`N;fR+$&x6(4^Jml+@xck5r$mJ|tjiUnvhGrh~N6 zbqAZ3m2;lgb|@5aY%4SN>pA7o&0sP*+ybvFTVJEO3)2~RS6U{(qhAqP1+wh{EFS0& zeUh>|zPJAZYoP_s#YF->gPJ#W(w@_>i27M-@x{EMTw8XhEfizH389`Ocu=dfpC;bW z=|`h{Uxf5-fnOLXOs&5`__coY*WjVyR^T4V6JpI5w~`Uw^|QB;KR@y9+#`rqIJP}f za6b`0R0I3P4-FIsMTjdN*3R_rp|6be+#zInqd^+}m9D_?wo3!lJZ8Ab4OgT-1%L$pfVjBQ@Z}!T#;a=vc^a(AeHx}~&}%D( zc>E6b@96P-AsBopfF>*y$xb?fjhr~U*v7w9!w*oCQ;0eoxh8RtIN+GXFuC~{fMp>~ z+G+1?s!<){G=R=tSF<3>q<_S>z3flZdzNi})m(Iiyy&slYuC>20`bc4=qnj%s&$&T zRkrHmDJoPe*E45PiBG(hsQVy_nKpt-flUlBzny}-w0e(?WM|^-)@%4^B2?|coVm9F z*60@?jCUKZ)d=)s1QsO+no#IR!NDRigF%N*6gZZsy@j_yL;&b0m|E9;v*psC)a&qB zPJ~%1@GVf<^a3~B^xs_bm^oOahefKnX`_oIf5LDd>%tcOjPqXzq$EQvWsSZ6A@uG) z!;=RSZ;}XYF&xo+$+zw-?Lf`(hZ3)~`z4nrR~rs5XF#fhPSK#Z%NR$s9HQ6o5dC z5y_&}EwT2dbl-P>B4y1~`=Om5b=GkOw|iZkfcx%f$k@ZAp#Eja%VW+Hc46)kfd2n9 z%Qm3HKMh=i?uX%T2FY9lcQmSHe8TwNF8!?G=08ii(ue@G!ibn@PXOrL`Y!~iuu8dC zvvJif@z*{8me9bgxMUBk6WGi+Yxd*~;9{_KC$?u>W+2GE`myWuRg3p8)4KEhC5`88 zq{Fyumv0}iAAIYMoz{9GIzYLpd7q>YbuqGdlDW&V;orUbrEEZpC82MRlTn2B#DCH( zeSfm!+nMUCW}u8#T)>ntg-tt+AfRahbzT$TRy$xH(>oOLnc9HxS~zkQs4JbnCG%|D zJ8ij~Ha@N2x=5?p1^%QBD8JRH)N8S5t8RB{JfLBA?u7DU!DZGayOrJeScUF6!V-TD=`3_lkG2>7EuXpiMoWlJ8K2K_H)=7|Xa literal 0 HcmV?d00001 diff --git a/doc/doxygen/image/ne10_logo.png b/doc/doxygen/image/ne10_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..b9238d5667b49b3b6dc89619e97299a7aa44666f GIT binary patch literal 12179 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%0D?( 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 + * ├── android + * │   └── Android reference files + * ├── build + * │   └── directory for build-related files + * ├── common + * │   └── directory for common header, table and macro definition files + * ├── doc + * │   └── directory for documentations + * ├── inc + * │   └── directory for functions'heaeder files + * ├── modules + * │   ├── dsp + * │   │   ├── @link groupDSPs dsp module@endlink that provides a set of signal processing functions, such as complex/real FFT/IFFT, FIR and IIR + * │   │   └── test + * │   │   └── directory for test files + * │   ├── math + * │   │   ├── @link groupMaths math module@endlink that provides a set of vector/matrix algebra functions + * │   │   └── test + * │   │   └── directory for test files + * ├── samples + * │   └── @link groupSamples sample code@endlink + * ├── test + * │   ├── directory for test framework + * ├── tools + * │   ├── directory for tools such as Cformatter, doxygen, etc + * + * + *\par Modules Description + * Ne10 has a modular structure, which means that the package includes several shared or static libraries. + * Currently, the following modules are available: * * - @link groupMaths Math Functions@endlink * - @link groupDSPs Signal Processing Functions@endlink * - Physics functions * - Image Processing functions * - Others - *\par - *\image html ne10_library.png "Ne10 Library Description" * *\par License * - * The Ne10 is provided free of charge by ARM Limited and licensed under New BSD license. + * The Ne10 is provided free of charge by ARM Limited and licensed under New BSD License (http://en.wikipedia.org/wiki/BSD_licenses#3-clause_license_.28.22New_BSD_License.22_or_.22Modified_BSD_License.22.29). */ /** * @defgroup groupMaths Math Functions * - *\par Introduction * * This set of functions provide vector/matrix algebra functions that include * add, sub, multiply, div and so on. Currently, only the float (single precision) @@ -72,12 +104,17 @@ /** * @defgroup groupDSPs Signal Processing Functions * - *\par Introduction * * This set of functions provide some commonly used functions in signal processing, * such as complex/real FFT/IFFT, FIR and IIR. Currently, only the float (single precision) * data type is supported. */ +/** + * @defgroup groupSamples Sample Functions + * + * + * This set of functions provide some sample functions. + */ #ifndef NE10_H diff --git a/inc/NE10_dsp.h b/inc/NE10_dsp.h index fd6f308..d25a9cd 100644 --- a/inc/NE10_dsp.h +++ b/inc/NE10_dsp.h @@ -43,216 +43,255 @@ extern "C" { // function prototypes: /////////////////////////// -/* fft functions*/ - -/* function pointers*/ -extern void (*ne10_radix4_butterfly_float)(ne10_float32_t *pDst, - ne10_float32_t *pSrc, - ne10_uint16_t N, - ne10_float32_t *pCoef); - -extern void (*ne10_radix4_butterfly_inverse_float)(ne10_float32_t *pDst, - ne10_float32_t *pSrc, - ne10_uint16_t N, - ne10_float32_t *pCoef, - ne10_float32_t onebyN); - -extern void (*ne10_rfft_float)(const ne10_rfft_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_float32_t * pTemp); -/* init functions*/ -extern ne10_result_t ne10_cfft_radix4_init_float(ne10_cfft_radix4_instance_f32_t * S, - ne10_uint16_t fftLen, - ne10_uint8_t ifftFlag); - -extern ne10_result_t ne10_rfft_init_float(ne10_rfft_instance_f32_t * S, - ne10_cfft_radix4_instance_f32_t * S_CFFT, - ne10_uint32_t fftLen, - ne10_uint32_t ifftFlagR); -/* C version*/ -extern void ne10_radix4_butterfly_float_c(ne10_float32_t *pDst, - ne10_float32_t *pSrc, - ne10_uint16_t N, - ne10_float32_t *pCoef); - -extern void ne10_radix4_butterfly_inverse_float_c(ne10_float32_t *pDst, - ne10_float32_t *pSrc, - ne10_uint16_t N, - ne10_float32_t *pCoef, - ne10_float32_t onebyN); - -extern void ne10_rfft_float_c(const ne10_rfft_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_float32_t * pTemp); - - -/* NEON version*/ -extern void ne10_radix4_butterfly_float_neon(ne10_float32_t *pDst, - ne10_float32_t *pSrc, - ne10_uint16_t N, - ne10_float32_t *pCoef); - -extern void ne10_radix4_butterfly_inverse_float_neon(ne10_float32_t *pDst, - ne10_float32_t *pSrc, - ne10_uint16_t N, - ne10_float32_t *pCoef, - ne10_float32_t onebyN); - -extern void ne10_rfft_float_neon(const ne10_rfft_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_float32_t * pTemp); -/* fir functions*/ - -/* function pointers*/ -extern void (*ne10_fir_float)(const ne10_fir_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void (*ne10_fir_decimate_float)(const ne10_fir_decimate_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void (*ne10_fir_interpolate_float)(const ne10_fir_interpolate_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void (*ne10_fir_lattice_float)(const ne10_fir_lattice_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void (*ne10_fir_sparse_float)(ne10_fir_sparse_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_float32_t * pScratchIn, - ne10_uint32_t blockSize); - - -/* init functions*/ -extern ne10_result_t ne10_fir_init_float(ne10_fir_instance_f32_t * S, - ne10_uint16_t numTaps, - ne10_float32_t * pCoeffs, - ne10_float32_t * pState, - ne10_uint32_t blockSize); - -extern ne10_result_t ne10_fir_decimate_init_float(ne10_fir_decimate_instance_f32_t * S, - ne10_uint16_t numTaps, - ne10_uint8_t M, - ne10_float32_t * pCoeffs, - ne10_float32_t * pState, - ne10_uint32_t blockSize); - -extern ne10_result_t ne10_fir_interpolate_init_float(ne10_fir_interpolate_instance_f32_t * S, - ne10_uint8_t L, - ne10_uint16_t numTaps, - ne10_float32_t * pCoeffs, - ne10_float32_t * pState, - ne10_uint32_t blockSize); - -extern ne10_result_t ne10_fir_lattice_init_float(ne10_fir_lattice_instance_f32_t * S, - ne10_uint16_t numStages, - ne10_float32_t * pCoeffs, - ne10_float32_t * pState); - -extern ne10_result_t ne10_fir_sparse_init_float(ne10_fir_sparse_instance_f32_t * S, - ne10_uint16_t numTaps, - ne10_float32_t * pCoeffs, - ne10_float32_t * pState, - ne10_int32_t * pTapDelay, - ne10_uint16_t maxDelay, - ne10_uint32_t blockSize); - -/* C version*/ -extern void ne10_fir_float_c(const ne10_fir_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_decimate_float_c(const ne10_fir_decimate_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_interpolate_float_c(const ne10_fir_interpolate_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_lattice_float_c(const ne10_fir_lattice_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_sparse_float_c(ne10_fir_sparse_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_float32_t * pScratchIn, - ne10_uint32_t blockSize); - - -/* NEON version*/ -extern void ne10_fir_float_neon(const ne10_fir_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_decimate_float_neon(const ne10_fir_decimate_instance_f32_t * S, - ne10_float32_t *pSrc, - ne10_float32_t *pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_interpolate_float_neon(const ne10_fir_interpolate_instance_f32_t * S, - ne10_float32_t *pSrc, - ne10_float32_t *pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_lattice_float_neon(const ne10_fir_lattice_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -extern void ne10_fir_sparse_float_neon(ne10_fir_sparse_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_float32_t * pScratch, - ne10_uint32_t blockSize); - - -/* iir functions*/ - -/* function pointers*/ -extern void (*ne10_iir_lattice_float)(const ne10_iir_lattice_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -/* init functions*/ -extern ne10_result_t ne10_iir_lattice_init_float(ne10_iir_lattice_instance_f32_t * S, - ne10_uint16_t numStages, - ne10_float32_t * pkCoeffs, - ne10_float32_t * pvCoeffs, - ne10_float32_t * pState, - ne10_uint32_t blockSize); - - -/* C version*/ -extern void ne10_iir_lattice_float_c(const ne10_iir_lattice_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - -/* NEON version*/ -extern void ne10_iir_lattice_float_neon(const ne10_iir_lattice_instance_f32_t * S, - ne10_float32_t * pSrc, - ne10_float32_t * pDst, - ne10_uint32_t blockSize); - + /* fft functions*/ + + /* function pointers*/ + extern void (*ne10_radix4_butterfly_float) (ne10_float32_t *pDst, + ne10_float32_t *pSrc, + ne10_uint16_t N, + ne10_float32_t *pCoef); + + extern void (*ne10_radix4_butterfly_inverse_float) (ne10_float32_t *pDst, + ne10_float32_t *pSrc, + ne10_uint16_t N, + ne10_float32_t *pCoef, + ne10_float32_t onebyN); + + extern void (*ne10_rfft_float) (const ne10_rfft_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_float32_t * pTemp); + /* init functions*/ + extern ne10_result_t ne10_cfft_radix4_init_float (ne10_cfft_radix4_instance_f32_t * S, + ne10_uint16_t fftLen, + ne10_uint8_t ifftFlag); + + extern ne10_result_t ne10_rfft_init_float (ne10_rfft_instance_f32_t * S, + ne10_cfft_radix4_instance_f32_t * S_CFFT, + ne10_uint32_t fftLen, + ne10_uint32_t ifftFlagR); + /* C version*/ + extern void ne10_radix4_butterfly_float_c (ne10_float32_t *pDst, + ne10_float32_t *pSrc, + ne10_uint16_t N, + ne10_float32_t *pCoef); + + extern void ne10_radix4_butterfly_inverse_float_c (ne10_float32_t *pDst, + ne10_float32_t *pSrc, + ne10_uint16_t N, + ne10_float32_t *pCoef, + ne10_float32_t onebyN); + + extern void ne10_rfft_float_c (const ne10_rfft_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_float32_t * pTemp); + + + /* NEON version*/ + /** + * @addtogroup CFFT_CIFFT + * @{ + */ + extern void ne10_radix4_butterfly_float_neon (ne10_float32_t *pDst, + ne10_float32_t *pSrc, + ne10_uint16_t N, + ne10_float32_t *pCoef); + + extern void ne10_radix4_butterfly_inverse_float_neon (ne10_float32_t *pDst, + ne10_float32_t *pSrc, + ne10_uint16_t N, + ne10_float32_t *pCoef, + ne10_float32_t onebyN); + /** @} */ //end of CFFT_CIFFT group + + + extern void ne10_rfft_float_neon (const ne10_rfft_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_float32_t * pTemp); + + + /* fir functions*/ + + /* function pointers*/ + extern void (*ne10_fir_float) (const ne10_fir_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void (*ne10_fir_decimate_float) (const ne10_fir_decimate_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void (*ne10_fir_interpolate_float) (const ne10_fir_interpolate_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void (*ne10_fir_lattice_float) (const ne10_fir_lattice_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void (*ne10_fir_sparse_float) (ne10_fir_sparse_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_float32_t * pScratchIn, + ne10_uint32_t blockSize); + + + /* init functions*/ + extern ne10_result_t ne10_fir_init_float (ne10_fir_instance_f32_t * S, + ne10_uint16_t numTaps, + ne10_float32_t * pCoeffs, + ne10_float32_t * pState, + ne10_uint32_t blockSize); + + extern ne10_result_t ne10_fir_decimate_init_float (ne10_fir_decimate_instance_f32_t * S, + ne10_uint16_t numTaps, + ne10_uint8_t M, + ne10_float32_t * pCoeffs, + ne10_float32_t * pState, + ne10_uint32_t blockSize); + + extern ne10_result_t ne10_fir_interpolate_init_float (ne10_fir_interpolate_instance_f32_t * S, + ne10_uint8_t L, + ne10_uint16_t numTaps, + ne10_float32_t * pCoeffs, + ne10_float32_t * pState, + ne10_uint32_t blockSize); + + extern ne10_result_t ne10_fir_lattice_init_float (ne10_fir_lattice_instance_f32_t * S, + ne10_uint16_t numStages, + ne10_float32_t * pCoeffs, + ne10_float32_t * pState); + + extern ne10_result_t ne10_fir_sparse_init_float (ne10_fir_sparse_instance_f32_t * S, + ne10_uint16_t numTaps, + ne10_float32_t * pCoeffs, + ne10_float32_t * pState, + ne10_int32_t * pTapDelay, + ne10_uint16_t maxDelay, + ne10_uint32_t blockSize); + + /* C version*/ + extern void ne10_fir_float_c (const ne10_fir_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void ne10_fir_decimate_float_c (const ne10_fir_decimate_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void ne10_fir_interpolate_float_c (const ne10_fir_interpolate_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void ne10_fir_lattice_float_c (const ne10_fir_lattice_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + extern void ne10_fir_sparse_float_c (ne10_fir_sparse_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_float32_t * pScratchIn, + ne10_uint32_t blockSize); + + + /* NEON version*/ + + /** + * @addtogroup FIR + * @{ + */ + extern void ne10_fir_float_neon (const ne10_fir_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + /** @} */ //end of FIR group + + /** + * @addtogroup FIR_decimate + * @{ + */ + extern void ne10_fir_decimate_float_neon (const ne10_fir_decimate_instance_f32_t * S, + ne10_float32_t *pSrc, + ne10_float32_t *pDst, + ne10_uint32_t blockSize); + /** @} */ //end of FIR_decimate group + + /** + * @addtogroup FIR_Interpolate + * @{ + */ + extern void ne10_fir_interpolate_float_neon (const ne10_fir_interpolate_instance_f32_t * S, + ne10_float32_t *pSrc, + ne10_float32_t *pDst, + ne10_uint32_t blockSize); + /** @} */ //end of FIR_interpolate group + + /** + * @addtogroup FIR_Lattice + * @{ + */ + extern void ne10_fir_lattice_float_neon (const ne10_fir_lattice_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + /** @} */ //end of FIR_Lattice group + + /** + * @addtogroup FIR_Sparse + * @{ + */ + extern void ne10_fir_sparse_float_neon (ne10_fir_sparse_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_float32_t * pScratch, + ne10_uint32_t blockSize); + /** @} */ //end of FIR_sparse group + + + /* iir functions*/ + + /* function pointers*/ + extern void (*ne10_iir_lattice_float) (const ne10_iir_lattice_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + /* init functions*/ + extern ne10_result_t ne10_iir_lattice_init_float (ne10_iir_lattice_instance_f32_t * S, + ne10_uint16_t numStages, + ne10_float32_t * pkCoeffs, + ne10_float32_t * pvCoeffs, + ne10_float32_t * pState, + ne10_uint32_t blockSize); + + + /* C version*/ + extern void ne10_iir_lattice_float_c (const ne10_iir_lattice_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + + /* NEON version*/ + + /** + * @addtogroup IIR_Lattice + * @{ + */ + extern void ne10_iir_lattice_float_neon (const ne10_iir_lattice_instance_f32_t * S, + ne10_float32_t * pSrc, + ne10_float32_t * pDst, + ne10_uint32_t blockSize); + /** @} */ //end of IIR_Lattice group #ifdef __cplusplus } #endif diff --git a/inc/NE10_init.h b/inc/NE10_init.h index 6f8b746..d72a6c7 100644 --- a/inc/NE10_init.h +++ b/inc/NE10_init.h @@ -34,21 +34,21 @@ extern "C" { #endif -/*! - This routine returns NE10_OK if the running platform supports NEON, otherwise it returns NE10_ERR - */ -extern ne10_result_t ne10_HasNEON(); - -/*! - This routine initializes all the function pointers. - */ -extern ne10_result_t ne10_init(); - -/*! - This routine initializes all the math function pointers defined in "NE10_math.h" with pointers to ARM NEON or ARM VFP implementations. - */ -extern ne10_result_t ne10_init_math(ne10_int32_t is_NEON_available); -extern ne10_result_t ne10_init_dsp (ne10_int32_t is_NEON_available); + /*! + This routine returns NE10_OK if the running platform supports NEON, otherwise it returns NE10_ERR + */ + extern ne10_result_t ne10_HasNEON(); + + /*! + This routine initializes all the function pointers. + */ + extern ne10_result_t ne10_init(); + + /*! + This routine initializes all the math function pointers defined in "NE10_math.h" with pointers to ARM NEON or ARM VFP implementations. + */ + extern ne10_result_t ne10_init_math (ne10_int32_t is_NEON_available); + extern ne10_result_t ne10_init_dsp (ne10_int32_t is_NEON_available); #ifdef __cplusplus } diff --git a/inc/NE10_math.h b/inc/NE10_math.h index 720f1ef..1e6e966 100644 --- a/inc/NE10_math.h +++ b/inc/NE10_math.h @@ -46,1158 +46,1436 @@ extern "C" { // ## Vector-Constant Arithmetic ## -/*! - Adds a constant scalar value to all the elements of an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst The constant scalar added to the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_addc_float)(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Adds a constant 2D vector to all of the vectors in an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 2D vector added to the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_addc_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Adds a constant 3D vector to all of the vectors in an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 3D vector added to the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_addc_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Adds a constant 4D vector to all of the vectors in an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 4D vector added to the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_addc_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -/*! - Subtracts a constant scalar from all the elements of an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst The constant scalar subtracted from the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_subc_float)(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Subtracts a constant 2D vector from all of the vectors in an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 2D vector subtracted from the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_subc_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Subtracts a constant 3D vector from all of the vectors in an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 3D vector subtracted from the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_subc_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Subtracts a constant 4D vector from all of the vectors in an input array and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 4D vector subtracted from the input values - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_subc_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -/*! - Subtracts the elements of an input array from a constant scalar and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst The constant scalar to subtract the input values from - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_rsbc_float)(ne10_float32_t * dst, ne10_float32_t *src, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Subtracts the vectors in an input array from a constant 2D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 2D vector to subtract the input values from - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_rsbc_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Subtracts the vectors in an input array from a constant 3D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 3D vector to subtract the input values from - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_rsbc_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Subtracts the vectors in an input array from a constant 4D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 4D vector to subtract the input values from - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_rsbc_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -/*! - Multiplies the elements of an input array by a constant scalar and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst The constant scalar to multiply the input values with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mulc_float)(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Multiplies the components of 2D vectors in an input array by the components of a constant 2D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 2D vector to multiply the input values with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mulc_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Multiplies the components of 3D vectors in an input array by the components of a constant 3D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 3D vector to multiply the input values with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mulc_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Multiplies the components of 4D vectors in an input array by the components of a constant 4D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 4D vector to multiply the input values with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mulc_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -/*! - Divides the elements of an input array by a constant scalar and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst The constant scalar to divide the input values by - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_divc_float)(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Divides the components of 2D vectors in an input array with the components of a constant 2D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 2D vector to divide the input values by - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_divc_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Divides the components of 3D vectors in an input array with the components of a constant 3D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 3D vector to divide the input values by - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_divc_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Divides the components of 4D vectors in an input array with the components of a constant 4D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 4D vector to divide the input values by - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_divc_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -/*! - Sets the elements of an input array to a constant scalar and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] cst The constant scalar to set the input values to - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_setc_float)(ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Sets the components of 2D vectors in an input array to the components of a constant 2D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] cst Pointer to the 2D vector to set the input values to - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_setc_vec2f)(ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Sets the components of 3D vectors in an input array to the components of a constant 3D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] cst Pointer to the 3D vector to set the input values to - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_setc_vec3f)(ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Sets the components of 3D vectors in an input array to the components of a constant 3D vector and stores the results in an output array. - @param[out] dst Pointer to the destination array - @param[in] cst Pointer to the 4D vector to set the input values to - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_setc_vec4f)(ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -/*! - Multiplies each entry in the source array (src) by cst, then adds the result to - the corresponding item of the accumulation array (acc), and stores the result in the destination array. - @param[out] dst Pointer to the destination array - @param[in] acc The corresponding elemetn is added to the result of the multiplication - @param[in] src Pointer to the source array - @param[in] cst The constant scalar to multiply the input elements with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mlac_float)(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -/*! - Multiplies each entry in the source array (src) by the 2D vector cst, then adds the result to - the corresponding item of the accumulation array (acc), and stores the result in the destination array. - @param[out] dst Pointer to the destination array - @param[in] acc The corresponding elemetn is added to the result of the multiplication - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 2D vector to multiply the input vectors with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mlac_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -/*! - Multiplies each entry in the source array (src) by the 3D vector cst, then adds the result to - the corresponding item of the accumulation array (acc), and stores the result in the destination array. - @param[out] dst Pointer to the destination array - @param[in] acc The corresponding elemetn is added to the result of the multiplication - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 3D vector to multiply the input vectors with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mlac_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -/*! - Multiplies each entry in the source array (src) by the 4D vector cst, then adds the result to - the corresponding item of the accumulation array (acc), and stores the result in the destination array. - @param[out] dst Pointer to the destination array - @param[in] acc The corresponding elemetn is added to the result of the multiplication - @param[in] src Pointer to the source array - @param[in] cst Pointer to the 4D vector to multiply the input vectors with - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_mlac_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -// ## Arithmetic functions over arrays of cst values ## - -/*! - Adds the elements of src1 to the elements of src2 and stores the results in the dst. - @param[out] dst Pointer to the destination array - @param[in] src1 The first array to use as the input array - @param[in] src2 The second array to use as the input array - @param[in] count The number of items in the two input arrays - */ -extern ne10_result_t (*ne10_add_float)(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -/*! - Subtracts the elements of src2 from the elements of src2 and stores the results in the dst. - @param[out] dst Pointer to the destination array - @param[in] src1 The first array to use as the input array - @param[in] src2 The second array to use as the input array - @param[in] count The number of items in the two input arrays - */ -extern ne10_result_t (*ne10_sub_float)(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -/*! - Multiplies the elements of src1 by the elements of src2 and stores the results in the dst. - @param[out] dst Pointer to the destination array - @param[in] src1 The first array to use as the input array - @param[in] src2 The second array to use as the input array - @param[in] count The number of items in the two input arrays - */ -extern ne10_result_t (*ne10_mul_float)(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -/*! - Divides the elements of src1 by the elements of src2 and stores the results in the dst. - @param[out] dst Pointer to the destination array - @param[in] src1 The first array to use as the input array - @param[in] src2 The second array to use as the input array - @param[in] count The number of items in the two input arrays - */ -extern ne10_result_t (*ne10_div_float)(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -/*! - Performs a multiply and accumulate operation using the corresponding elements in acc, src1, and src2. - @param[out] dst Pointer to the destination array - @param[in] acc These elemtns are added to the result of the multiplication operation - @param[in] src1 The first array to use as the input array - @param[in] src2 The second array to use as the input array - @param[in] count The number of items in the two input arrays - */ -extern ne10_result_t (*ne10_mla_float)(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -/*! - Calculates the absolute value of each element in the source array and stores the result in the corresponding entry of the destination array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_abs_float)(ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); - - - -// ## Operations on Vectors ## -/*! - Returns length of 2D vectors in corresponding elements of the output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_len_vec2f)(ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -/*! - Returns length of 3D vectors in corresponding elements of the output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_len_vec3f)(ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -/*! - Returns length of 4D vectors in corresponding elements of the output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_len_vec4f)(ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -/*! - Normalizes 2D vectors of the input array and stores them in the corresponding elements of the output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_normalize_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -/*! - Normalizes 3D vectors of the input array and stores them in the corresponding elements of the output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_normalize_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -/*! - Normalizes 4D vectors of the input array and stores them in the corresponding elements of the output array. - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_normalize_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - - -/*! - Generates a 2D vector from the absolute values of each of the components of an input vector - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_abs_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -/*! - Generates a 3D vector from the absolute values of each of the components of an input vector - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_abs_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -/*! - Generates a 4D vector from the absolute values of each of the components of an input vector - @param[out] dst Pointer to the destination array - @param[in] src Pointer to the source array - @param[in] count The number of items in the input array - */ -extern ne10_result_t (*ne10_abs_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -// ## SIMD Component-wise Arithmetic on Two Vectors ## - -/*! - Multiplies the components of a 2D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vmul_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -/*! - Multiplies the components of a 3D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vmul_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -/*! - Multiplies the components of a 4D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vmul_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -/*! - Divides the components of a 2D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the nominators' source array - @param[in] src2 Pointer to the denominators' source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vdiv_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -/*! - Divides the components of a 3D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the nominators' source array - @param[in] src2 Pointer to the denominators' source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vdiv_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -/*! - Divides the components of a 4D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the nominators' source array - @param[in] src2 Pointer to the denominators' source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vdiv_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -/*! - Performs a multiply and accumulate operation on the components of a 2D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vmla_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -/*! - Performs a multiply and accumulate operation on the components of a 3D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vmla_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -/*! - Performs a multiply and accumulate operation on the components of a 4D vector with the corresponding components of another - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_vmla_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -// ## Vector-Vector Algebra ## - -/*! - Vector addition of two 2D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_add_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -/*! - Vector addition of two 3D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_add_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -/*! - Vector addition of two 4D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_add_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -/*! - Vector subtraction of two 2D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_sub_vec2f)(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -/*! - Vector subtraction of two 3D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_sub_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -/*! - Vector subtraction of two 4D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_sub_vec4f)(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -/*! - Dot product of two 2D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_dot_vec2f)(ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -/*! - Dot product of two 3D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_dot_vec3f)(ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -/*! - Dot product of two 4D vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_dot_vec4f)(ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -/*! - Performs a cross product operation on the two input vectors - @param[out] dst Pointer to the destination array - @param[in] src1 Pointer to the first source array - @param[in] src2 Pointer to the second source array - @param[in] count The number of items in the input arrays - */ -extern ne10_result_t (*ne10_cross_vec3f)(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); - - - - -// ## Matrix-Constant Arithmetic ## - -// ne10_mat4x4f_t -extern ne10_result_t (*ne10_addmat_4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_submat_4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_mulmat_4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_divmat_4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_setmat_4x4f)(ne10_mat4x4f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t (*ne10_addmat_3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_submat_3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_mulmat_3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_divmat_3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_setmat_3x3f)(ne10_mat3x3f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t (*ne10_addmat_2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_submat_2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_mulmat_2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_divmat_2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_setmat_2x2f)(ne10_mat2x2f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - - - -// ## Operations on Matrices ## - -extern ne10_result_t (*ne10_detmat_4x4f)(ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_detmat_3x3f)(ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_detmat_2x2f)(ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t (*ne10_invmat_4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_invmat_3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_invmat_2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t (*ne10_transmat_4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_identitymat_4x4f)(ne10_mat4x4f_t * dst, ne10_uint32_t count); - -extern ne10_result_t (*ne10_transmat_3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_identitymat_3x3f)(ne10_mat3x3f_t * dst, ne10_uint32_t count); - -extern ne10_result_t (*ne10_transmat_2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_identitymat_2x2f)(ne10_mat2x2f_t * dst, ne10_uint32_t count); - - - -// ## Matrix-Vector Algebra ## -extern ne10_result_t (*ne10_mulcmatvec_cm4x4f_v4f)(ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_mulcmatvec_cm3x3f_v3f)(ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t (*ne10_mulcmatvec_cm2x2f_v2f)(ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); - - -// ## Matrix-Matrix Algebra ## -extern ne10_result_t (*ne10_multrans_mat4x4f)(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_multrans_mat3x3f)(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t (*ne10_multrans_mat2x2f)(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); - - -/////////////////////////// -// C function prototypes: -/////////////////////////// - - -// ## Vector-Constant Arithmetic ## - -extern ne10_result_t ne10_addc_float_c(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_subc_float_c(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) - - - -extern ne10_result_t ne10_rsbc_float_c(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst - - - -extern ne10_result_t ne10_mulc_float_c(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_divc_float_c(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_setc_float_c(ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec2f_c(ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec3f_c(ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec4f_c(ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_mlac_float_c(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - -// ## Arithmetic functions over arrays of cst values ## -extern ne10_result_t ne10_add_float_c(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_float_c(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mul_float_c(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_div_float_c(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mla_float_c(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_abs_float_c(ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); - -// ## Operations on Vectors ## -extern ne10_result_t ne10_len_vec2f_c(ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_len_vec3f_c(ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_len_vec4f_c(ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -extern ne10_result_t ne10_normalize_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_normalize_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_normalize_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -extern ne10_result_t ne10_abs_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_abs_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_abs_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -// ## SIMD Component-wise Arithmetic on Two Vectors ## -extern ne10_result_t ne10_vmul_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmul_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmul_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_vdiv_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vdiv_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vdiv_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_vmla_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmla_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmla_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -// ## Vector-Vector Algebra ## -extern ne10_result_t ne10_add_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_add_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_add_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_sub_vec2f_c(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_vec4f_c(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_dot_vec2f_c(ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_dot_vec3f_c(ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_dot_vec4f_c(ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_cross_vec3f_c(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); - - - -// ## Matrix-Constant Arithmetic ## - -// ne10_mat4x4f_t -extern ne10_result_t ne10_addmat_4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_4x4f_c(ne10_mat4x4f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t ne10_addmat_3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_3x3f_c(ne10_mat3x3f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t ne10_addmat_2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_2x2f_c(ne10_mat2x2f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - - - -// ## Operations on Matrices ## - -extern ne10_result_t ne10_detmat_4x4f_c(ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_detmat_3x3f_c(ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_detmat_2x2f_c(ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t ne10_invmat_4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_invmat_3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_invmat_2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_4x4f_c(ne10_mat4x4f_t * dst, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_3x3f_c(ne10_mat3x3f_t * dst, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_2x2f_c(ne10_mat2x2f_t * dst, ne10_uint32_t count); - - - -// ## Matrix-Vector Algebra ## -extern ne10_result_t ne10_mulcmatvec_cm4x4f_v4f_c(ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_mulcmatvec_cm3x3f_v3f_c(ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_mulcmatvec_cm2x2f_v2f_c(ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); - - -// ## Matrix-Matrix Algebra ## -extern ne10_result_t ne10_multrans_mat4x4f_c(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_multrans_mat3x3f_c(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_multrans_mat2x2f_c(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); - - -///////////////////////////// -// NEON function prototypes: -///////////////////////////// - - -// ## Vector-Constant Arithmetic ## - -extern ne10_result_t ne10_addc_float_neon(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_subc_float_neon(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) - - - -extern ne10_result_t ne10_rsbc_float_neon(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst - - - -extern ne10_result_t ne10_mulc_float_neon(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_divc_float_neon(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_setc_float_neon(ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec2f_neon(ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec3f_neon(ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec4f_neon(ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_mlac_float_neon(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -// ## Arithmetic functions over arrays of cst values ## -extern ne10_result_t ne10_add_float_neon(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_float_neon(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mul_float_neon(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_div_float_neon(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mla_float_neon(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_abs_float_neon(ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); - -// ## Operations on Vectors ## -extern ne10_result_t ne10_len_vec2f_neon(ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_len_vec3f_neon(ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_len_vec4f_neon(ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -extern ne10_result_t ne10_normalize_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_normalize_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_normalize_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -extern ne10_result_t ne10_abs_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_abs_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_abs_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -// ## SIMD Component-wise Arithmetic on Two Vectors ## -extern ne10_result_t ne10_vmul_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmul_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmul_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_vdiv_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vdiv_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vdiv_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_vmla_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmla_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmla_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -// ## Vector-Vector Algebra ## -extern ne10_result_t ne10_add_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_add_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_add_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_sub_vec2f_neon(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_vec4f_neon(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_dot_vec2f_neon(ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_dot_vec3f_neon(ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_dot_vec4f_neon(ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_cross_vec3f_neon(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); - - - -// ## Matrix-Constant Arithmetic ## - -// ne10_mat4x4f_t -extern ne10_result_t ne10_addmat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_4x4f_neon(ne10_mat4x4f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t ne10_addmat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_3x3f_neon(ne10_mat3x3f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t ne10_addmat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_2x2f_neon(ne10_mat2x2f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - - - -// ## Operations on Matrices ## - - -extern ne10_result_t ne10_detmat_4x4f_neon(ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_detmat_3x3f_neon(ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_detmat_2x2f_neon(ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t ne10_invmat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_invmat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_invmat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_4x4f_neon(ne10_mat4x4f_t * dst, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_3x3f_neon(ne10_mat3x3f_t * dst, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_2x2f_neon(ne10_mat2x2f_t * dst, ne10_uint32_t count); - - - -// ## Matrix-Vector Algebra ## -extern ne10_result_t ne10_mulcmatvec_cm4x4f_v4f_neon(ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_mulcmatvec_cm3x3f_v3f_neon(ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_mulcmatvec_cm2x2f_v2f_neon(ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); - - - - -// ## Matrix-Matrix Algebra ## -extern ne10_result_t ne10_multrans_mat4x4f_neon(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_multrans_mat3x3f_neon(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_multrans_mat2x2f_neon(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); - - -//////////////////////////// -// VFP function prototypes: -//////////////////////////// - -// ## Vector-Constant Arithmetic ## - -extern ne10_result_t ne10_addc_float_asm(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_addc_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_subc_float_asm(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) -extern ne10_result_t ne10_subc_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) - - - -extern ne10_result_t ne10_rsbc_float_asm(ne10_float32_t * dst, ne10_float32_t *src, const ne10_float32_t cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t *src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t *src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst -extern ne10_result_t ne10_rsbc_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t *src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst - - - -extern ne10_result_t ne10_mulc_float_asm(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mulc_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_divc_float_asm(ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_divc_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_setc_float_asm(ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec2f_asm(ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec3f_asm(ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_setc_vec4f_asm(ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -extern ne10_result_t ne10_mlac_float_asm(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); -extern ne10_result_t ne10_mlac_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); - - - -// ## Arithmetic functions over arrays of cst values ## -extern ne10_result_t ne10_add_float_asm(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_float_asm(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mul_float_asm(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_div_float_asm(ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mla_float_asm(ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_abs_float_asm(ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); - -// ## Operations on Vectors ## -extern ne10_result_t ne10_len_vec2f_asm(ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_len_vec3f_asm(ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_len_vec4f_asm(ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -extern ne10_result_t ne10_normalize_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_normalize_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_normalize_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -extern ne10_result_t ne10_abs_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_abs_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_abs_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); - - - -// ## SIMD Component-wise Arithmetic on Two Vectors ## -extern ne10_result_t ne10_vmul_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmul_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmul_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_vdiv_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vdiv_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vdiv_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_vmla_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmla_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_vmla_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -// ## Vector-Vector Algebra ## -extern ne10_result_t ne10_add_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_add_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_add_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_sub_vec2f_asm(ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_sub_vec4f_asm(ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_dot_vec2f_asm(ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_dot_vec3f_asm(ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_dot_vec4f_asm(ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); - - - -extern ne10_result_t ne10_cross_vec3f_asm(ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); - - -// ## Matrix-Constant Arithmetic ## - -// ne10_mat4x4f_t -extern ne10_result_t ne10_addmat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_4x4f_asm(ne10_mat4x4f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t ne10_addmat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_3x3f_asm(ne10_mat3x3f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - -extern ne10_result_t ne10_addmat_2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_submat_2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_mulmat_2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_divmat_2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_setmat_2x2f_asm(ne10_mat2x2f_t * dst, const ne10_float32_t cst, ne10_uint32_t count); - - - -// ## Operations on Matrices ## - -extern ne10_result_t ne10_detmat_4x4f_asm(ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_detmat_3x3f_asm(ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_detmat_2x2f_asm(ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t ne10_invmat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_invmat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_invmat_2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_4x4f_asm(ne10_mat4x4f_t * dst, ne10_uint32_t count); - -extern ne10_result_t ne10_transmat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identitymat_3x3f_asm(ne10_mat3x3f_t * dst, ne10_uint32_t count); - -extern ne10_result_t ne10_trans_mat2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_identity_mat2x2f_asm(ne10_mat2x2f_t * dst, ne10_uint32_t count); - - - -// ## Matrix-Vector Algebra ## -extern ne10_result_t ne10_mulcmatvec_cm4x4f_v4f_asm(ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_mulcmatvec_cm3x3f_v3f_asm(ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); -extern ne10_result_t ne10_mulcmatvec_cm2x2f_v2f_asm(ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); - - - - -// ## Matrix-Matrix Algebra ## -extern ne10_result_t ne10_multrans_mat4x4f_asm(ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_multrans_mat3x3f_asm(ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); -extern ne10_result_t ne10_multrans_mat2x2f_asm(ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + /** + * @ingroup groupMaths + */ + + /** + * @defgroup ADD_VEC Vector Add + * + * \par + * These functions implement the vector add operation for float data type. + */ + + /** + * @addtogroup ADD_VEC + * @{ + */ + + /** + * Adds a constant scalar value to all the elements of an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_addc_float_c, ne10_addc_float_neon and ne10_addc_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst The constant scalar added to the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_addc_float) (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_float_c (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_float_neon (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_float_asm (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + /** + * Adds a constant 2D vector to all of the vectors in an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_addc_vec2f_c, ne10_addc_vec2f_neon and ne10_addc_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 2D vector added to the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_addc_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + /** + * Adds a constant 3D vector to all of the vectors in an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_addc_vec3f_c, ne10_addc_vec3f_neon and ne10_addc_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 3D vector added to the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_addc_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + /** + * Adds a constant 4D vector to all of the vectors in an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_addc_vec4f_c, ne10_addc_vec4f_neon and ne10_addc_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 4D vector added to the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_addc_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_addc_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + + + /** + * Adds the elements of src1 to the elements of src2 and stores the results in the dst. + * This function point could be pointed to one of ne10_add_float_c, ne10_add_float_neon and ne10_add_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 The first array to use as the input array + * @param[in] src2 The second array to use as the input array + * @param[in] count The number of items in the two input arrays + */ + extern ne10_result_t (*ne10_add_float) (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + /** + * Vector addition of two 2D vectors. + * This function point could be pointed to one of ne10_add_vec2f_c, ne10_add_vec2f_neon and ne10_add_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_add_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + /** + * Vector addition of two 3D vectors. + * This function point could be pointed to one of ne10_add_vec3f_c, ne10_add_vec3f_neon and ne10_add_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_add_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** + * Vector addition of two 4D vectors. + * This function point could be pointed to one of ne10_add_vec4f_c, ne10_add_vec4f_neon and ne10_add_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_add_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_add_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Add group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup ADD_MAT Matrix Add + * + * \par + * These functions implement the matrix add operation for float data type. + */ + + /** + * @addtogroup ADD_MAT + * @{ + */ + + /** + * Vector addition of two 4x4 matrixs. + * This function point could be pointed to one of ne10_addmat_4x4f_c, ne10_addmat_4x4f_neon and ne10_addmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_addmat_4x4f) (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + /** + * Vector addition of two 3x3 matrixs. + * This function point could be pointed to one of ne10_addmat_3x3f_c, ne10_addmat_3x3f_neon and ne10_addmat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_addmat_3x3f) (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + /** + * Vector addition of two 2x2 matrixs. + * This function point could be pointed to one of ne10_addmat_2x2f_c, ne10_addmat_2x2f_neon and ne10_addmat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_addmat_2x2f) (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_addmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + /** @} */ //end of Matrix Add group + + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup SUB_VEC Vector Sub + * + * \par + * These functions implement the vector sub operation for float data type. + */ + + /** + * @addtogroup SUB_VEC + * @{ + */ + + /** + * Subtracts a constant scalar from all the elements of an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_subc_float_c, ne10_subc_float_neon and ne10_subc_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst The constant scalar subtracted from the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_subc_float) (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_subc_float_c (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_float_neon (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_float_asm (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract cst from the element(s) + /** + * Subtracts a constant 2D vector from all of the vectors in an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_subc_vec2f_c, ne10_subc_vec2f_neon and ne10_subc_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 2D vector subtracted from the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_subc_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_subc_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + /** + * Subtracts a constant 3D vector from all of the vectors in an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_subc_vec3f_c, ne10_subc_vec3f_neon and ne10_subc_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 3D vector subtracted from the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_subc_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_subc_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + /** + * Subtracts a constant 4D vector from all of the vectors in an input array and stores the results in an output array. + * This function point could be pointed to one of ne10_subc_vec4f_c, ne10_subc_vec4f_neon and ne10_subc_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 4D vector subtracted from the input values + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_subc_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_subc_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + extern ne10_result_t ne10_subc_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract cst from the element(s) + + /** + * Subtracts the elements of src2 from the elements of src1 and stores the results in the dst. + * This function point could be pointed to one of ne10_sub_float_c, ne10_sub_float_neon and ne10_sub_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 The first array to use as the input array + * @param[in] src2 The second array to use as the input array + * @param[in] count The number of items in the two input arrays + */ + extern ne10_result_t (*ne10_sub_float) (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + /** + * Vector subtraction of two 2D vectors. + * This function point could be pointed to one of ne10_sub_vec2f_c, ne10_sub_vec2f_neon and ne10_sub_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_sub_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + /** + * Vector subtraction of two 3D vectors. + * This function point could be pointed to one of ne10_sub_vec3f_c, ne10_sub_vec3f_neon and ne10_sub_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_sub_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** + * Vector subtraction of two 4D vectors. + * This function point could be pointed to one of ne10_sub_vec4f_c, ne10_sub_vec4f_neon and ne10_sub_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_sub_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_sub_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Sub group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup RSBC Vector Rsbc + * + * \par + * These functions implement the vector rsbc operation for float data type. + */ + + /** + * @addtogroup RSBC + * @{ + */ + /** + * Subtracts the elements of an input array from a constant scalar and stores the results in an output array. + * This function point could be pointed to one of ne10_rsbc_float_c, ne10_rsbc_float_neon and ne10_rsbc_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst The constant scalar to subtract the input values from + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_rsbc_float) (ne10_float32_t * dst, ne10_float32_t *src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_rsbc_float_c (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_float_neon (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_float_asm (ne10_float32_t * dst, ne10_float32_t *src, const ne10_float32_t cst, ne10_uint32_t count); // subtract element(s) from a cst + /** + * Subtracts the vectors in an input array from a constant 2D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_rsbc_vec2f_c, ne10_rsbc_vec2f_neon and ne10_rsbc_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 2D vector to subtract the input values from + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_rsbc_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_rsbc_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t *src, const ne10_vec2f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + /** + * Subtracts the vectors in an input array from a constant 3D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_rsbc_vec3f_c, ne10_rsbc_vec3f_neon and ne10_rsbc_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 3D vector to subtract the input values from + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_rsbc_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_rsbc_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t *src, const ne10_vec3f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + /** + * Subtracts the vectors in an input array from a constant 4D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_rsbc_vec4f_c, ne10_rsbc_vec4f_neon and ne10_rsbc_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 4D vector to subtract the input values from + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_rsbc_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_rsbc_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + extern ne10_result_t ne10_rsbc_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t *src, const ne10_vec4f_t * cst, ne10_uint32_t count); // subtract element(s) from a cst + /** @} */ //end of Vector RSBC group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup SUB_MAT Matrix Sub + * + * \par + * These functions implement the matrix sub operation for float data type. + */ + + /** + * @addtogroup SUB_MAT + * @{ + */ + /** + * Matrix subtraction of two 4x4 matrixs. + * This function point could be pointed to one of ne10_submat_4x4f_c, ne10_submat_4x4f_neon and ne10_submat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_submat_4x4f) (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + + /** + * Matrix subtraction of two 3x3 matrixs. + * This function point could be pointed to one of ne10_submat_3x3f_c, ne10_submat_3x3f_neon and ne10_submat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_submat_3x3f) (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + + /** + * Matrix subtraction of two 2x2 matrixs. + * This function point could be pointed to one of ne10_submat_2x2f_c, ne10_submat_2x2f_neon and ne10_submat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_submat_2x2f) (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_submat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + /** @} */ //end of Matrix Sub group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup MUL_VEC Vector Multiply + * + * \par + * These functions implement the vector multiply operation for float data type. + */ + + /** + * @addtogroup MUL_VEC + * @{ + */ + + /** + * Multiplies the elements of an input array by a constant scalar and stores the results in an output array. + * This function point could be pointed to one of ne10_mulc_float_c, ne10_mulc_float_neon and ne10_mulc_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst The constant scalar to multiply the input values with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mulc_float) (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_float_c (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_float_neon (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_float_asm (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + /** + * Multiplies the components of 2D vectors in an input array by the components of a constant 2D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_mulc_vec2f_c, ne10_mulc_vec2f_neon and ne10_mulc_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 2D vector to multiply the input values with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mulc_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + /** + * Multiplies the components of 3D vectors in an input array by the components of a constant 3D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_mulc_vec3f_c, ne10_mulc_vec3f_neon and ne10_mulc_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 3D vector to multiply the input values with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mulc_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + /** + * Multiplies the components of 4D vectors in an input array by the components of a constant 4D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_mulc_vec4f_c, ne10_mulc_vec4f_neon and ne10_mulc_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 4D vector to multiply the input values with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mulc_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mulc_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + + /** + * Multiplies the elements of src1 by the elements of src2 and stores the results in the dst. + * This function point could be pointed to one of ne10_mul_float_c, ne10_mul_float_neon and ne10_mul_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 The first array to use as the input array + * @param[in] src2 The second array to use as the input array + * @param[in] count The number of items in the two input arrays + */ + extern ne10_result_t (*ne10_mul_float) (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mul_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mul_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mul_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + /** + * Multiplies the components of a 2D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vmul_vec2f_c, ne10_vmul_vec2f_neon and ne10_vmul_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vmul_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + /** + * Multiplies the components of a 3D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vmul_vec3f_c, ne10_vmul_vec3f_neon and ne10_vmul_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vmul_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** + * Multiplies the components of a 4D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vmul_vec4f_c, ne10_vmul_vec4f_neon and ne10_vmul_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vmul_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmul_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Multiply group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup MLA_VEC Vector Multiply-Accumulator + * + * \par + * These functions implement the vector multiply-accumulator operation for float data type. + */ + + /** + * @addtogroup MLA_VEC + * @{ + */ + + /** + * Multiplies each entry in the source array (src) by cst, then adds the result to + * the corresponding item of the accumulation array (acc), and stores the result in the destination array. + * This function point could be pointed to one of ne10_mlac_float_c, ne10_mlac_float_neon and ne10_mlac_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] acc The corresponding elemetn is added to the result of the multiplication + * @param[in] src Pointer to the source array + * @param[in] cst The constant scalar to multiply the input elements with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mlac_float) (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_float_c (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_float_neon (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_float_asm (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + /** + * Multiplies each entry in the source array (src) by the 2D vector cst, then adds the result to + * the corresponding item of the accumulation array (acc), and stores the result in the destination array. + * This function point could be pointed to one of ne10_mlac_vec2f_c, ne10_mlac_vec2f_neon and ne10_mlac_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] acc The corresponding elemetn is added to the result of the multiplication + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 2D vector to multiply the input vectors with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mlac_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + /** + * Multiplies each entry in the source array (src) by the 3D vector cst, then adds the result to + * the corresponding item of the accumulation array (acc), and stores the result in the destination array. + * This function point could be pointed to one of ne10_mlac_vec3f_c, ne10_mlac_vec3f_neon and ne10_mlac_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] acc The corresponding elemetn is added to the result of the multiplication + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 3D vector to multiply the input vectors with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mlac_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + /** + * Multiplies each entry in the source array (src) by the 4D vector cst, then adds the result to + * the corresponding item of the accumulation array (acc), and stores the result in the destination array. + * This function point could be pointed to one of ne10_mlac_vec4f_c, ne10_mlac_vec4f_neon and ne10_mlac_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] acc The corresponding elemetn is added to the result of the multiplication + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 4D vector to multiply the input vectors with + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_mlac_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_mlac_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + + /** + * Performs a multiply and accumulate operation using the corresponding elements in acc, src1, and src2. + * This function point could be pointed to one of ne10_mla_float_c, ne10_mla_float_neon and ne10_mla_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] acc These elemtns are added to the result of the multiplication operation + * @param[in] src1 The first array to use as the input array + * @param[in] src2 The second array to use as the input array + * @param[in] count The number of items in the two input arrays + */ + extern ne10_result_t (*ne10_mla_float) (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mla_float_c (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mla_float_neon (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mla_float_asm (ne10_float32_t * dst, ne10_float32_t * acc, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + /** + * Performs a multiply and accumulate operation on the components of a 2D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vmla_vec2f_c, ne10_vmla_vec2f_neon and ne10_vmla_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vmla_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * acc, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + /** + * Performs a multiply and accumulate operation on the components of a 3D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vmla_vec3f_c, ne10_vmla_vec3f_neon and ne10_vmla_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vmla_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * acc, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** + * Performs a multiply and accumulate operation on the components of a 4D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vmla_vec4f_c, ne10_vmla_vec4f_neon and ne10_vmla_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vmla_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vmla_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * acc, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Multiply-Accumulator group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup MUL_MAT Matrix Multiply + * + * \par + * These functions implement the matrix multiply operation for float data type. + */ + + /** + * @addtogroup MUL_MAT + * @{ + */ + + /** + * Matrix multiplication of two 4x4 matrixs. + * This function point could be pointed to one of ne10_mulmat_4x4f_c, ne10_mulmat_4x4f_neon and ne10_mulmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_mulmat_4x4f) (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + + /** + * Matrix multiplication of two 3x3 matrixs. + * This function point could be pointed to one of ne10_mulmat_3x3f_c, ne10_mulmat_3x3f_neon and ne10_mulmat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_mulmat_3x3f) (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + + /** + * Matrix multiplication of two 2x2 matrixs. + * This function point could be pointed to one of ne10_mulmat_2x2f_c, ne10_mulmat_2x2f_neon and ne10_mulmat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_mulmat_2x2f) (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_mulmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + /** @} */ //end of Matrix Multiply group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup MUL_MAT_VEC Matrix Vector Multiply + * + * \par + * These functions implement the matrix vector multiply operation for float data type. + */ + + /** + * @addtogroup MUL_MAT_VEC + * @{ + */ + /** + * Matrix multiplication of 4x4 matrix and 4D vector. + * This function point could be pointed to one of ne10_mulcmatvec_cm4x4f_v4f_c, ne10_mulcmatvec_cm4x4f_v4f_neon and ne10_mulcmatvec_cm4x4f_v4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst Pointer to the matrix to multiply the input values with + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_mulcmatvec_cm4x4f_v4f) (ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm4x4f_v4f_c (ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm4x4f_v4f_neon (ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm4x4f_v4f_asm (ne10_vec4f_t * dst, const ne10_mat4x4f_t * cst, ne10_vec4f_t * src, ne10_uint32_t count); + /** + * Matrix multiplication of 3x3 matrix and 3D vector. + * This function point could be pointed to one of ne10_mulcmatvec_cm3x3f_v3f_c, ne10_mulcmatvec_cm3x3f_v3f_neon and ne10_mulcmatvec_cm3x3f_v3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst Pointer to the matrix to multiply the input values with + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_mulcmatvec_cm3x3f_v3f) (ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm3x3f_v3f_c (ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm3x3f_v3f_neon (ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm3x3f_v3f_asm (ne10_vec3f_t * dst, const ne10_mat3x3f_t * cst, ne10_vec3f_t * src, ne10_uint32_t count); + /** + * Matrix multiplication of 2x2 matrix and 2D vector. + * This function point could be pointed to one of ne10_mulcmatvec_cm2x2f_v2f_c, ne10_mulcmatvec_cm2x2f_v2f_neon and ne10_mulcmatvec_cm2x2f_v2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst Pointer to the matrix to multiply the input values with + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_mulcmatvec_cm2x2f_v2f) (ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm2x2f_v2f_c (ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm2x2f_v2f_neon (ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_mulcmatvec_cm2x2f_v2f_asm (ne10_vec2f_t * dst, const ne10_mat2x2f_t * cst, ne10_vec2f_t * src, ne10_uint32_t count); + + /** @} */ //end of Matrix Vector Multiply group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup DIV_VEC Vector Div + * + * \par + * These functions implement the vector division operation for float data type. + */ + + /** + * @addtogroup DIV_VEC + * @{ + */ + + /** + * Divides the elements of an input array by a constant scalar and stores the results in an output array. + * This function point could be pointed to one of ne10_divc_float_c, ne10_divc_float_neon and ne10_divc_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst The constant scalar to divide the input values by + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_divc_float) (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_float_c (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_float_neon (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_float_asm (ne10_float32_t * dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count); + /** + * Divides the components of 2D vectors in an input array with the components of a constant 2D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_divc_vec2f_c, ne10_divc_vec2f_neon and ne10_divc_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 2D vector to divide the input values by + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_divc_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count); + /** + * Divides the components of 3D vectors in an input array with the components of a constant 3D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_divc_vec3f_c, ne10_divc_vec3f_neon and ne10_divc_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 3D vector to divide the input values by + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_divc_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count); + /** + * Divides the components of 4D vectors in an input array with the components of a constant 4D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_divc_vec4f_c, ne10_divc_vec4f_neon and ne10_divc_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] cst Pointer to the 4D vector to divide the input values by + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_divc_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_divc_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count); + /** + * Divides the elements of src1 by the elements of src2 and stores the results in the dst. + * This function point could be pointed to one of ne10_div_float_c, ne10_div_float_neon and ne10_div_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 The first array to use as the input array + * @param[in] src2 The second array to use as the input array + * @param[in] count The number of items in the two input arrays + */ + extern ne10_result_t (*ne10_div_float) (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_div_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_div_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_div_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count); + /** + * Divides the components of a 2D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vdiv_vec2f_c, ne10_vdiv_vec2f_neon and ne10_vdiv_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the nominators' source array + * @param[in] src2 Pointer to the denominators' source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vdiv_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + /** + * Divides the components of a 3D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vdiv_vec3f_c, ne10_vdiv_vec3f_neon and ne10_vdiv_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the nominators' source array + * @param[in] src2 Pointer to the denominators' source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vdiv_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** + * Divides the components of a 4D vector with the corresponding components of another. + * This function point could be pointed to one of ne10_vdiv_vec4f_c, ne10_vdiv_vec4f_neon and ne10_vdiv_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the nominators' source array + * @param[in] src2 Pointer to the denominators' source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_vdiv_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_vdiv_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Div group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup DIV_MAT Matrix Div + * + * \par + * These functions implement the matrix division operation for float data type. + */ + + /** + * @addtogroup DIV_MAT + * @{ + */ + + /** + * Divides the components of a 4x4 matrix with the corresponding components of another. + * This function point could be pointed to one of ne10_divmat_4x4f_c, ne10_divmat_4x4f_neon and ne10_divmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the nominators' source array + * @param[in] src2 Pointer to the denominators' source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_divmat_4x4f) (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count); + /** + * Divides the components of a 3x3 matrix with the corresponding components of another. + * This function point could be pointed to one of ne10_divmat_3x3f_c, ne10_divmat_3x3f_neon and ne10_divmat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the nominators' source array + * @param[in] src2 Pointer to the denominators' source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_divmat_3x3f) (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count); + /** + * Divides the components of a 2x2 matrix with the corresponding components of another. + * This function point could be pointed to one of ne10_divmat_2x2f_c, ne10_divmat_2x2f_neon and ne10_divmat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the nominators' source array + * @param[in] src2 Pointer to the denominators' source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_divmat_2x2f) (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_divmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count); + /** @} */ //end of Matrix Div group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup SETC_VEC Vector Setc + * + * \par + * These functions implement vector setc operation for float data type. + */ + + /** + * @addtogroup SETC_VEC + * @{ + */ + + /** + * Sets the elements of an input array to a constant scalar and stores the results in an output array. + * This function point could be pointed to one of ne10_setc_float_c, ne10_setc_float_neon and ne10_setc_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst The constant scalar to set the input values to + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_setc_float) (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_float_c (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_float_neon (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_float_asm (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count); + /** + * Sets the components of 2D vectors in an input array to the components of a constant 2D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_setc_vec2f_c, ne10_setc_vec2f_neon and ne10_setc_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst Pointer to the 2D vector to set the input values to + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_setc_vec2f) (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec2f_c (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec2f_neon (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec2f_asm (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count); + /** + * Sets the components of 3D vectors in an input array to the components of a constant 3D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_setc_vec3f_c, ne10_setc_vec3f_neon and ne10_setc_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst Pointer to the 3D vector to set the input values to + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_setc_vec3f) (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec3f_c (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec3f_neon (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec3f_asm (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count); + /** + * Sets the components of 4D vectors in an input array to the components of a constant 3D vector and stores the results in an output array. + * This function point could be pointed to one of ne10_setc_vec4f_c, ne10_setc_vec4f_neon and ne10_setc_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] cst Pointer to the 4D vector to set the input values to + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_setc_vec4f) (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec4f_c (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec4f_neon (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); + extern ne10_result_t ne10_setc_vec4f_asm (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count); + /** @} */ //end of Vector Setc group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup LEN_VEC Vector Len + * + * \par + * These functions implement vector len operation for float data type. + */ + + /** + * @addtogroup LEN_VEC + * @{ + */ + /** + * Returns length of 2D vectors in corresponding elements of the output array. + * This function point could be pointed to one of ne10_len_vec2f_c, ne10_len_vec2f_neon and ne10_len_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_len_vec2f) (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec2f_c (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec2f_neon (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec2f_asm (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + /** + * Returns length of 3D vectors in corresponding elements of the output array. + * This function point could be pointed to one of ne10_len_vec3f_c, ne10_len_vec3f_neon and ne10_len_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_len_vec3f) (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec3f_c (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec3f_neon (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec3f_asm (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + /** + * Returns length of 4D vectors in corresponding elements of the output array. + * This function point could be pointed to one of ne10_len_vec4f_c, ne10_len_vec4f_neon and ne10_len_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_len_vec4f) (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec4f_c (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec4f_neon (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_len_vec4f_asm (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + /** @} */ //end of Vector Len group + + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup NORM_VEC Vector Normalize + * + * \par + * These functions implement vector normalize operation for float data type. + */ + + /** + * @addtogroup NORM_VEC + * @{ + */ + /** + * Normalizes 2D vectors of the input array and stores them in the corresponding elements of the output array. + * This function point could be pointed to one of ne10_normalize_vec2f_c, ne10_normalize_vec2f_neon and ne10_normalize_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_normalize_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + /** + * Normalizes 3D vectors of the input array and stores them in the corresponding elements of the output array. + * This function point could be pointed to one of ne10_normalize_vec3f_c, ne10_normalize_vec3f_neon and ne10_normalize_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_normalize_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + /** + * Normalizes 4D vectors of the input array and stores them in the corresponding elements of the output array. + * This function point could be pointed to one of ne10_normalize_vec4f_c, ne10_normalize_vec4f_neon and ne10_normalize_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_normalize_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_normalize_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + /** @} */ //end of Vector Normalize group + + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup ABS_VEC Vector Abs + * + * \par + * These functions implement vector abs operation for float data type. + */ + + /** + * @addtogroup ABS_VEC + * @{ + */ + + /** + * Calculates the absolute value of each element in the source array and stores the result in the corresponding entry of the destination array. + * This function point could be pointed to one of ne10_abs_float_c, ne10_abs_float_neon and ne10_abs_float_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_abs_float) (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_float_c (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_float_neon (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_float_asm (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count); + /** + * Generates a 2D vector from the absolute values of each of the components of an input vector. + * This function point could be pointed to one of ne10_abs_vec2f_c, ne10_abs_vec2f_neon and ne10_abs_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_abs_vec2f) (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count); + /** + * Generates a 3D vector from the absolute values of each of the components of an input vector. + * This function point could be pointed to one of ne10_abs_vec3f_c, ne10_abs_vec3f_neon and ne10_abs_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_abs_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count); + /** + * Generates a 4D vector from the absolute values of each of the components of an input vector. + * This function point could be pointed to one of ne10_abs_vec4f_c, ne10_abs_vec4f_neon and ne10_abs_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_abs_vec4f) (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_abs_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count); + /** @} */ //end of Vector Abs group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup DOT_VEC Vector Dot + * + * \par + * These functions implement vector dot operation for float data type. + */ + + /** + * @addtogroup DOT_VEC + * @{ + */ + /** + * Dot product of two 2D vectors. + * This function point could be pointed to one of ne10_dot_vec2f_c, ne10_dot_vec2f_neon and ne10_dot_vec2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_dot_vec2f) (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec2f_c (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec2f_neon (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec2f_asm (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count); + /** + * Dot product of two 3D vectors. + * This function point could be pointed to one of ne10_dot_vec3f_c, ne10_dot_vec3f_neon and ne10_dot_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_dot_vec3f) (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec3f_c (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec3f_neon (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec3f_asm (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** + * Dot product of two 4D vectors. + * This function point could be pointed to one of ne10_dot_vec4f_c, ne10_dot_vec4f_neon and ne10_dot_vec4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_dot_vec4f) (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec4f_c (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec4f_neon (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_dot_vec4f_asm (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Dot group + + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup CROSS_VEC Vector Cross + * + * \par + * These functions implement vector cross operation for float data type. + */ + + /** + * @addtogroup CROSS_VEC + * @{ + */ + + /** + * Performs a cross product operation on the two input vectors. + * This function point could be pointed to one of ne10_cross_vec3f_c, ne10_cross_vec3f_neon and ne10_cross_vec3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src1 Pointer to the first source array + * @param[in] src2 Pointer to the second source array + * @param[in] count The number of items in the input arrays + */ + extern ne10_result_t (*ne10_cross_vec3f) (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_cross_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_cross_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + extern ne10_result_t ne10_cross_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count); + /** @} */ //end of Vector Cross group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup DET_MAT Matrix Determinant + * + * \par + * These functions implement matrix determinant operation for float data type. + */ + + /** + * @addtogroup DET_MAT + * @{ + */ + + /** + * Calculate the determinant of a 4x4 matrix. + * This function point could be pointed to one of ne10_detmat_4x4f_c, ne10_detmat_4x4f_neon and ne10_detmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_detmat_4x4f) (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_4x4f_c (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_4x4f_neon (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_4x4f_asm (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + /** + * Calculate the determinant of a 3x3 matrix. + * This function point could be pointed to one of ne10_detmat_3x3f_c, ne10_detmat_3x3f_neon and ne10_detmat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_detmat_3x3f) (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_3x3f_c (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_3x3f_neon (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_3x3f_asm (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + /** + * Calculate the determinant of a 2x2 matrix. + * This function point could be pointed to one of ne10_detmat_2x2f_c, ne10_detmat_2x2f_neon and ne10_detmat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_detmat_2x2f) (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_2x2f_c (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_2x2f_neon (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_detmat_2x2f_asm (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + /** @} */ //end of Matrix Determinant group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup INV_MAT Matrix Invertible + * + * \par + * These functions implement matrix invertible operation for float data type. + */ + + /** + * @addtogroup INV_MAT + * @{ + */ + /** + * Calculate the invertible matrix of a 4x4 matrix. + * This function point could be pointed to one of ne10_invmat_4x4f_c, ne10_invmat_4x4f_neon and ne10_invmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_invmat_4x4f) (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + /** + * Calculate the invertible matrix of a 3x3 matrix. + * This function point could be pointed to one of ne10_invmat_3x3f_c, ne10_invmat_3x3f_neon and ne10_invmat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_invmat_3x3f) (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + /** + * Calculate the invertible matrix of a 2x2 matrix. + * This function point could be pointed to one of ne10_invmat_2x2f_c, ne10_invmat_2x2f_neon and ne10_invmat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_invmat_2x2f) (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_invmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + /** @} */ //end of Matrix Invertible group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup TRANS_MAT Matrix Transpose + * + * \par + * These functions implement matrix transpose operation for float data type. + */ + + /** + * @addtogroup TRANS_MAT + * @{ + */ + /** + * Calculate the transpose matrix of a 4x4 matrix. + * This function point could be pointed to one of ne10_transmat_4x4f_c, ne10_transmat_4x4f_neon and ne10_transmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_transmat_4x4f) (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count); + /** + * Calculate the transpose matrix of a 4x4 matrix. + * This function point could be pointed to one of ne10_transmat_4x4f_c, ne10_transmat_4x4f_neon and ne10_transmat_4x4f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_transmat_3x3f) (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count); + /** + * Calculate the transpose matrix of a 3x3 matrix. + * This function point could be pointed to one of ne10_transmat_3x3f_c, ne10_transmat_3x3f_neon and ne10_transmat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] src Pointer to the source array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_transmat_2x2f) (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_transmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + extern ne10_result_t ne10_trans_mat2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count); + /** @} */ //end of Matrix Transpose group + + /** + * @ingroup groupMaths + */ + + /** + * @defgroup IDENTITY_MAT Matrix Identity + * + * \par + * These functions implement matrix identity operation for float data type. + */ + + /** + * @addtogroup IDENTITY_MAT + * @{ + */ + /** + * Set the identity matrix of a 2x2 matrix. + * This function point could be pointed to one of ne10_identitymat_2x2f_c, ne10_identitymat_2x2f_neon and ne10_identitymat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_identitymat_4x4f) (ne10_mat4x4f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_4x4f_c (ne10_mat4x4f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_uint32_t count); + /** + * Set the identity matrix of a 3x3 matrix. + * This function point could be pointed to one of ne10_identitymat_3x3f_c, ne10_identitymat_3x3f_neon and ne10_identitymat_3x3f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_identitymat_3x3f) (ne10_mat3x3f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_3x3f_c (ne10_mat3x3f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_uint32_t count); + /** + * Set the identity matrix of a 2x2 matrix. + * This function point could be pointed to one of ne10_identitymat_2x2f_c, ne10_identitymat_2x2f_neon and ne10_identitymat_2x2f_asm. + * @param[out] dst Pointer to the destination array + * @param[in] count The number of items in the input array + */ + extern ne10_result_t (*ne10_identitymat_2x2f) (ne10_mat2x2f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_2x2f_c (ne10_mat2x2f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identitymat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_uint32_t count); + extern ne10_result_t ne10_identity_mat2x2f_asm (ne10_mat2x2f_t * dst, ne10_uint32_t count); + /** @} */ //end of Matrix Identity group #ifdef __cplusplus } diff --git a/inc/NE10_types.h b/inc/NE10_types.h index 4416631..ce49005 100644 --- a/inc/NE10_types.h +++ b/inc/NE10_types.h @@ -62,43 +62,56 @@ typedef float ne10_float32_t; typedef double ne10_float64_t; typedef int ne10_result_t; // resulting [error-]code +/** + * @brief a 2-tuple of ne10_float32_t values. + */ typedef struct { - ne10_float32_t x; - ne10_float32_t y; -} ne10_vec2f_t; // a 2-tuple of ne10_float32_t values + ne10_float32_t x; + ne10_float32_t y; +} ne10_vec2f_t; +/** + * @brief a 3-tuple of ne10_float32_t values. + */ typedef struct { - ne10_float32_t x; - ne10_float32_t y; - ne10_float32_t z; -} ne10_vec3f_t; // a 3-tuple of ne10_float32_t values + ne10_float32_t x; + ne10_float32_t y; + ne10_float32_t z; +} ne10_vec3f_t; +/** + * @brief a 4-tuple of ne10_float32_t values. + */ typedef struct { - ne10_float32_t x; - ne10_float32_t y; - ne10_float32_t z; - ne10_float32_t w; -} ne10_vec4f_t; // a 4-tuple of ne10_float32_t values + ne10_float32_t x; + ne10_float32_t y; + ne10_float32_t z; + ne10_float32_t w; +} ne10_vec4f_t; ///////////////////////////////////////////////////////// // definitions for matrix ///////////////////////////////////////////////////////// -typedef struct { ne10_float32_t r1; ne10_float32_t r2; } __attribute__((packed)) ne10_mat_row2f; +typedef struct +{ + ne10_float32_t r1; + ne10_float32_t r2; +} __attribute__ ( (packed)) ne10_mat_row2f; typedef struct { - ne10_mat_row2f c1; - ne10_mat_row2f c2; + ne10_mat_row2f c1; + ne10_mat_row2f c2; -} __attribute__((packed)) ne10_mat2x2f_t; // a 2x2 matrix +} __attribute__ ( (packed)) ne10_mat2x2f_t; // a 2x2 matrix -static inline void createColumnMajorMatrix2x2( ne10_mat2x2f_t * outMat, ne10_float32_t m11, ne10_float32_t m21, ne10_float32_t m12, ne10_float32_t m22) +static inline void createColumnMajorMatrix2x2 (ne10_mat2x2f_t * outMat, ne10_float32_t m11, ne10_float32_t m21, ne10_float32_t m12, ne10_float32_t m22) { - assert( NULL != outMat ); + assert (NULL != outMat); outMat->c1.r1 = m11; outMat->c1.r2 = m21; @@ -107,21 +120,26 @@ static inline void createColumnMajorMatrix2x2( ne10_mat2x2f_t * outMat, ne10_flo } -typedef struct { ne10_float32_t r1; ne10_float32_t r2; ne10_float32_t r3; } __attribute__((packed)) ne10_mat_row3f; +typedef struct +{ + ne10_float32_t r1; + ne10_float32_t r2; + ne10_float32_t r3; +} __attribute__ ( (packed)) ne10_mat_row3f; typedef struct { - ne10_mat_row3f c1; - ne10_mat_row3f c2; - ne10_mat_row3f c3; + ne10_mat_row3f c1; + ne10_mat_row3f c2; + ne10_mat_row3f c3; -} __attribute__((packed)) ne10_mat3x3f_t; // a 3x3 matrix +} __attribute__ ( (packed)) ne10_mat3x3f_t; // a 3x3 matrix -static inline void createColumnMajorMatrix3x3( ne10_mat3x3f_t * outMat, ne10_float32_t m11, ne10_float32_t m21, ne10_float32_t m31, - ne10_float32_t m12, ne10_float32_t m22, ne10_float32_t m32, - ne10_float32_t m13, ne10_float32_t m23, ne10_float32_t m33) +static inline void createColumnMajorMatrix3x3 (ne10_mat3x3f_t * outMat, ne10_float32_t m11, ne10_float32_t m21, ne10_float32_t m31, + ne10_float32_t m12, ne10_float32_t m22, ne10_float32_t m32, + ne10_float32_t m13, ne10_float32_t m23, ne10_float32_t m33) { - assert( NULL != outMat ); + assert (NULL != outMat); outMat->c1.r1 = m11; outMat->c1.r2 = m21; @@ -137,23 +155,29 @@ static inline void createColumnMajorMatrix3x3( ne10_mat3x3f_t * outMat, ne10_flo } -typedef struct { ne10_float32_t r1; ne10_float32_t r2; ne10_float32_t r3; ne10_float32_t r4; } __attribute__((packed)) ne10_mat_row4f; +typedef struct +{ + ne10_float32_t r1; + ne10_float32_t r2; + ne10_float32_t r3; + ne10_float32_t r4; +} __attribute__ ( (packed)) ne10_mat_row4f; typedef struct { - ne10_mat_row4f c1; - ne10_mat_row4f c2; - ne10_mat_row4f c3; - ne10_mat_row4f c4; + ne10_mat_row4f c1; + ne10_mat_row4f c2; + ne10_mat_row4f c3; + ne10_mat_row4f c4; -} __attribute__((packed)) ne10_mat4x4f_t; // a 4x4 matrix +} __attribute__ ( (packed)) ne10_mat4x4f_t; // a 4x4 matrix -static inline void createColumnMajorMatrix4x4( ne10_mat4x4f_t * outMat, ne10_float32_t m11, ne10_float32_t m21, ne10_float32_t m31, ne10_float32_t m41, - ne10_float32_t m12, ne10_float32_t m22, ne10_float32_t m32, ne10_float32_t m42, - ne10_float32_t m13, ne10_float32_t m23, ne10_float32_t m33, ne10_float32_t m43, - ne10_float32_t m14, ne10_float32_t m24, ne10_float32_t m34, ne10_float32_t m44) +static inline void createColumnMajorMatrix4x4 (ne10_mat4x4f_t * outMat, ne10_float32_t m11, ne10_float32_t m21, ne10_float32_t m31, ne10_float32_t m41, + ne10_float32_t m12, ne10_float32_t m22, ne10_float32_t m32, ne10_float32_t m42, + ne10_float32_t m13, ne10_float32_t m23, ne10_float32_t m33, ne10_float32_t m43, + ne10_float32_t m14, ne10_float32_t m24, ne10_float32_t m34, ne10_float32_t m44) { - assert( NULL != outMat ); + assert (NULL != outMat); outMat->c1.r1 = m11; outMat->c1.r2 = m21; @@ -189,7 +213,7 @@ typedef struct ne10_uint8_t ifft_flag; /**< Flag for selection of CFFT/ICFFT */ ne10_uint8_t bit_reverse_flag; /**< Flag for selection of bitreversal or not */ ne10_float32_t *p_twiddle; /**< Points to the twiddle factors array. The array is of length 2 * MaxFFTSize. */ - ne10_uint16_t *p_bit_rev_table; /**< Points to the bit reversal array. The array is of size MaxFFTSize/4 */ + ne10_uint16_t *p_bit_rev_table; /**< Points to the bit reversal array. The array is of size MaxFFTSize/4 */ ne10_uint16_t twid_coef_modifier; /**< Modifier to support different FFT sizes with same twiddle table */ ne10_uint16_t bit_rev_factor; /**< Modifier to support different FFT sizes with same bit reversal table */ ne10_float32_t one_by_fft_len; /**< 1/(Length of the FFT). */ @@ -214,7 +238,7 @@ typedef struct // definitions for fir ///////////////////////////////////////////////////////// -/* +/** * @brief Instance structure for the floating-point FIR filter. */ typedef struct @@ -224,7 +248,7 @@ typedef struct ne10_float32_t *pCoeffs; /**< Points to the coefficient array. The array is of length numTaps. */ } ne10_fir_instance_f32_t; -/* +/** * @brief Instance structure for the floating point FIR Lattice filter. */ typedef struct @@ -234,7 +258,7 @@ typedef struct ne10_float32_t *pCoeffs; /**< Points to the coefficient array. The array is of length numStages. */ } ne10_fir_lattice_instance_f32_t; -/* +/** * @brief Instance structure for the floating-point FIR Decimation. */ typedef struct @@ -245,7 +269,7 @@ typedef struct ne10_float32_t *pState; /**< Points to the state variable array. The array is of length numTaps+maxBlockSize-1. */ } ne10_fir_decimate_instance_f32_t; -/* +/** * @brief Instance structure for the floating-point FIR Interpolation. */ typedef struct @@ -256,7 +280,7 @@ typedef struct ne10_float32_t *pState; /**< Points to the state variable array. The array is of length numTaps+maxBlockSize-1. */ } ne10_fir_interpolate_instance_f32_t; -/* +/** * @brief Instance structure for the floating-point FIR Sparse filter. */ typedef struct diff --git a/modules/dsp/NE10_cfft.c b/modules/dsp/NE10_cfft.c index c8ad334..6063894 100644 --- a/modules/dsp/NE10_cfft.c +++ b/modules/dsp/NE10_cfft.c @@ -30,17 +30,141 @@ */ #include "NE10_types.h" +/** + * @ingroup groupDSPs + */ + +/** + * @defgroup CFFT_CIFFT Complex FFT + * + * \par + * Complex Fast Fourier Transform(CFFT) and Complex Inverse Fast Fourier Transform(CIFFT) is an efficient algorithm to compute Discrete Fourier Transform(DFT) and Inverse Discrete Fourier Transform(IDFT). + * Computational complexity of CFFT reduces drastically when compared to DFT. + * \par + * This set of functions implements CFFT/CIFFT + * for floating-point data types. The functions operate on out-of-place buffer which use different buffer for input and output. + * Complex input is stored in input buffer in an interleaved fashion. + * + * \par + * The functions operate on blocks of input and output data and each call to the function processes + * 2*fftLen samples through the transform. pSrc points to input arrays containing 2*fftLen values. + * \par + * The pDst points to the array of output buffer of size 2*fftLen and inputs and outputs are stored in an interleaved fashion as shown below. + * 
 {real[0], imag[0], real[1], imag[1],..}
+ * + * \par Lengths supported by the transform: + * \par + * Internally, the functions utilize a radix-4 decimation in frequency(DIF) algorithm + * and the size of the FFT supported are of the lengths [16, 64, 256, 1024]. + * + * + * \par Algorithm: + * + * Complex Fast Fourier Transform: + * \par + * Input real and imaginary data: + * 
+ * x(n) = xa + j * ya
+ * x(n+N/4 ) = xb + j * yb
+ * x(n+N/2 ) = xc + j * yc
+ * x(n+3N 4) = xd + j * yd
+ *
+ * where N is length of FFT + * \par + * Output real and imaginary data: + * 
+ * X(4r) = xa'+ j * ya'
+ * X(4r+1) = xb'+ j * yb'
+ * X(4r+2) = xc'+ j * yc'
+ * X(4r+3) = xd'+ j * yd'
+ *
+ * \par + * Twiddle factors for radix-4 FFT: + * 
+ * Wn = co1 + j * (- si1)
+ * W2n = co2 + j * (- si2)
+ * W3n = co3 + j * (- si3)
+ *
+ * + * \par + * \image html CFFT.gif "Radix-4 Decimation-in Frequency Complex Fast Fourier Transform" + * + * \par + * Output from Radix-4 CFFT Results in Digit reversal order. Interchange middle two branches of every butterfly results in Bit reversed output. + * \par + * Butterfly CFFT equations: + * 
+ * xa' = xa + xb + xc + xd
+ * ya' = ya + yb + yc + yd
+ * xc' = (xa+yb-xc-yd)* co1 + (ya-xb-yc+xd)* (si1)
+ * yc' = (ya-xb-yc+xd)* co1 - (xa+yb-xc-yd)* (si1)
+ * xb' = (xa-xb+xc-xd)* co2 + (ya-yb+yc-yd)* (si2)
+ * yb' = (ya-yb+yc-yd)* co2 - (xa-xb+xc-xd)* (si2)
+ * xd' = (xa-yb-xc+yd)* co3 + (ya+xb-yc-xd)* (si3)
+ * yd' = (ya+xb-yc-xd)* co3 - (xa-yb-xc+yd)* (si3)
+ *
+ * + * + * Complex Inverse Fast Fourier Transform: + * \par + * CIFFT uses same twiddle factor table as CFFT with modifications in the design equation as shown below. + * + * \par + * Modified Butterfly CIFFT equations: + * 
+ * xa' = xa + xb + xc + xd
+ * ya' = ya + yb + yc + yd
+ * xc' = (xa-yb-xc+yd)* co1 - (ya+xb-yc-xd)* (si1)
+ * yc' = (ya+xb-yc-xd)* co1 + (xa-yb-xc+yd)* (si1)
+ * xb' = (xa-xb+xc-xd)* co2 - (ya-yb+yc-yd)* (si2)
+ * yb' = (ya-yb+yc-yd)* co2 + (xa-xb+xc-xd)* (si2)
+ * xd' = (xa+yb-xc-yd)* co3 - (ya-xb-yc+xd)* (si3)
+ * yd' = (ya-xb-yc+xd)* co3 + (xa+yb-xc-yd)* (si3)
+ *
+ * + * \par Instance Structure + * A separate instance structure must be defined for each Instance but the twiddle factors and bit reversal tables can be reused. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Sets the values of the internal structure fields. + * - Initializes twiddle factor table and bit reversal table pointers + * \par + * Use of the initialization function is optional. + * However, if the initialization function is used, then the instance structure cannot be placed into a const data section. + * To place an instance structure into a const data section, the instance structure must be manually initialized. + * Manually initialize the instance structure as follows: + * 
+ *ne10_cfft_radix4_instance_f32_t = {fft_len, ifft_flag, bit_reverse_flag, p_twiddle, p_bit_rev_table, twid_coef_modifier, bit_rev_factor, one_by_fft_len};
+ *
+ * \par + * where fftLen length of CFFT/CIFFT; ifft_flag Flag for selection of CFFT or CIFFT(Set ifft_flag to calculate CIFFT otherwise calculates CFFT); + * bit_reverse_flag Flag for selection of output order(Set bitReverseFlag to output in normal order otherwise output in bit reversed order); + * p_twiddlepoints to array of twiddle coefficients; pBitRevTable points to the array of bit reversal table. + * p_bit_rev_table modifier for bit reversal table which supports all FFT lengths with same table. + * twid_coef_modifier modifier for twiddle factor table which supports all FFT lengths with same table; + * one_by_fft_len value of 1/fftLen to calculate CIFFT; + * + */ -/* -; * @brief Core radix-4 FFT of floating-point data. -; * @param[out] *pDst -; * @param[in] *pSrc points to the In-place buffer -; * @param[in] N length of FFT -; * @param[in] *pCoef points to the twiddle factors -; * @retureq none. -; * The function implements a Radix-4 Complex FFT -; */ +/** + * @addtogroup CFFT_CIFFT + * @{ + */ + +/** + * @brief Core radix-4 FFT of floating-point data. + * @param[out] *pDst point to the output buffer (out-of-place) + * @param[in] *pSrc point to the input buffer (out-of-place: the pSrc is used for intermedia buffer, so the input buffer is destroyed) + * @param[in] N length of FFT + * @param[in] *pCoef point to the twiddle factors + * @return none. + * The function implements a Radix-4 Complex FFT + * Can support FFT lengths of 16, 64, 256, 1024 + */ void ne10_radix4_butterfly_float_c( ne10_float32_t *pDst, @@ -256,15 +380,16 @@ void ne10_radix4_butterfly_float_c( } } -/* -; * @brief Core radix-4 IFFT of floating-point data. -; * @param[out] *pDst -; * @param[in] *pSrc points to the In-place buffer -; * @param[in] N length of FFT -; * @param[in] *pCoef points to the twiddle factors -; * @retureq none. -; * The function implements a Radix-4 Complex IFFT -; */ + +/** + * @brief Core radix-4 IFFT of floating-point data. + * @param[out] *pDst point to the output buffer (out-of-place) + * @param[in] *pSrc point to the input buffer (out-of-place: the pSrc is used for intermedia buffer, so the input buffer is destroyed) + * @param[in] N length of FFT + * @param[in] *pCoef point to the twiddle factors + * @return none. + * The function implements a Radix-4 Complex IFFT + */ void ne10_radix4_butterfly_inverse_float_c( ne10_float32_t *pDst, @@ -587,3 +712,7 @@ void ne10_radix4_butterfly_inverse_float_c( } } + +/** + * @} end of CFFT_CIFFT group + */ diff --git a/modules/dsp/NE10_fir.c b/modules/dsp/NE10_fir.c index 0c5cd78..07da376 100644 --- a/modules/dsp/NE10_fir.c +++ b/modules/dsp/NE10_fir.c @@ -38,6 +38,7 @@ /** * @defgroup FIR Finite Impulse Response (FIR) Filters * + * \par * This set of functions implements Finite Impulse Response (FIR) filters * for floating-point data types. * The functions operate on blocks of input and output data and each call to the function processes @@ -351,6 +352,93 @@ void ne10_fir_float_c (const ne10_fir_instance_f32_t * S, } } +/** @} */ //end of FIR group + +/** + * @ingroup groupDSPs + */ + +/** + * @defgroup FIR_Decimate Finite Impulse Response (FIR) Decimator + * + * \par + * These functions combine an FIR filter together with a decimator. + * They are used in multirate systems for reducing the sample rate of a signal without introducing aliasing distortion. + * Conceptually, the functions are equivalent to the block diagram below: + * \image html FIRDecimator.gif "Components included in the FIR Decimator functions" + * When decimating by a factor of M, the signal should be prefiltered by a lowpass filter with a normalized + * cutoff frequency of 1/M in order to prevent aliasing distortion. + * The user of the function is responsible for providing the filter coefficients. + * + * The FIR decimator functions provided in the CMSIS DSP Library combine the FIR filter and the decimator in an efficient manner. + * Instead of calculating all of the FIR filter outputs and discarding M-1 out of every M, only the + * samples output by the decimator are computed. + * The functions operate on blocks of input and output data. + * pSrc points to an array of blockSize input values and + * pDst points to an array of blockSize/M output values. + * In order to have an integer number of output samples blockSize + * must always be a multiple of the decimation factor M. + * + * The library provides functions for floating-point data types. + * + * \par Algorithm: + * The FIR portion of the algorithm uses the standard form filter: + * 
+ *    y[n] = b[0] * x[n] + b[1] * x[n-1] + b[2] * x[n-2] + ...+ b[numTaps-1] * x[n-numTaps+1]
+ *
+ * where, b[n] are the filter coefficients. + * \par + * The pCoeffs points to a coefficient array of size numTaps. + * Coefficients are stored in time reversed order. + * \par + * 
+ *    {b[numTaps-1], b[numTaps-2], b[N-2], ..., b[1], b[0]}
+ *
+ * \par + * pState points to a state array of size numTaps + blockSize - 1. + * Samples in the state buffer are stored in the order: + * \par + * 
+ *    {x[n-numTaps+1], x[n-numTaps], x[n-numTaps-1], x[n-numTaps-2]....x[0], x[1], ..., x[blockSize-1]}
+ *
+ * The state variables are updated after each block of data is processed, the coefficients are untouched. + * + * \par Instance Structure + * The coefficients and state variables for a filter are stored together in an instance data structure. + * A separate instance structure must be defined for each filter. + * Coefficient arrays may be shared among several instances while state variable array should be allocated separately. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Sets the values of the internal structure fields. + * - Zeros out the values in the state buffer. + * - Checks to make sure that the size of the input is a multiple of the decimation factor. + * + * \par + * Use of the initialization function is optional. + * However, if the initialization function is used, then the instance structure cannot be placed into a const data section. + * To place an instance structure into a const data section, the instance structure must be manually initialized. + * The code below statically initializes each of the 3 different data type filter instance structures + * 
+ *ne10_fir_decimate_instance_f32_t S = {M, numTaps, pCoeffs, pState};
+ *
+ * where M is the decimation factor; numTaps is the number of filter coefficients in the filter; + * pCoeffs is the address of the coefficient buffer; + * pState is the address of the state buffer. + * Be sure to set the values in the state buffer to zeros when doing static initialization. + * + * \par Fixed-Point Behavior + * Care must be taken when using the fixed-point versions of the FIR decimate filter functions. + * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + +/** + * @addtogroup FIR_Decimate + * @{ + */ /** * @brief Processing function for the floating-point FIR decimator. @@ -515,6 +603,102 @@ void ne10_fir_decimate_float_c (const ne10_fir_decimate_instance_f32_t * S, } } +/** @} */ //end of FIR_Decimate group + + +/** + * @ingroup groupDSPs + */ + +/** + * @defgroup FIR_Interpolate Finite Impulse Response (FIR) Interpolator + * + * \par + * These functions combine an upsampler (zero stuffer) and an FIR filter. + * They are used in multirate systems for increasing the sample rate of a signal without introducing high frequency images. + * Conceptually, the functions are equivalent to the block diagram below: + * \image html FIRInterpolator.gif "Components included in the FIR Interpolator functions" + * After upsampling by a factor of L, the signal should be filtered by a lowpass filter with a normalized + * cutoff frequency of 1/L in order to eliminate high frequency copies of the spectrum. + * The user of the function is responsible for providing the filter coefficients. + * + * The FIR interpolator functions provided in the CMSIS DSP Library combine the upsampler and FIR filter in an efficient manner. + * The upsampler inserts L-1 zeros between each sample. + * Instead of multiplying by these zero values, the FIR filter is designed to skip them. + * This leads to an efficient implementation without any wasted effort. + * The functions operate on blocks of input and output data. + * pSrc points to an array of blockSize input values and + * pDst points to an array of blockSize*L output values. + * + * The library provides functions for floating-point data types. + * + * \par Algorithm: + * The functions use a polyphase filter structure: + * 
+ *    y[n] = b[0] * x[n] + b[L]   * x[n-1] + ... + b[L*(phaseLength-1)] * x[n-phaseLength+1]
+ *    y[n+1] = b[1] * x[n] + b[L+1] * x[n-1] + ... + b[L*(phaseLength-1)+1] * x[n-phaseLength+1]
+ *    ...
+ *    y[n+(L-1)] = b[L-1] * x[n] + b[2*L-1] * x[n-1] + ....+ b[L*(phaseLength-1)+(L-1)] * x[n-phaseLength+1]
+ *
+ * This approach is more efficient than straightforward upsample-then-filter algorithms. + * With this method the computation is reduced by a factor of 1/L when compared to using a standard FIR filter. + * \par + * pCoeffs points to a coefficient array of size numTaps. + * numTaps must be a multiple of the interpolation factor L and this is checked by the + * initialization functions. + * Internally, the function divides the FIR filter's impulse response into shorter filters of length + * phaseLength=numTaps/L. + * Coefficients are stored in time reversed order. + * \par + * 
+ *    {b[numTaps-1], b[numTaps-2], b[N-2], ..., b[1], b[0]}
+ *
+ * \par + * pState points to a state array of size blockSize + phaseLength - 1. + * Samples in the state buffer are stored in the order: + * \par + * 
+ *    {x[n-phaseLength+1], x[n-phaseLength], x[n-phaseLength-1], x[n-phaseLength-2]....x[0], x[1], ..., x[blockSize-1]}
+ *
+ * The state variables are updated after each block of data is processed, the coefficients are untouched. + * + * \par Instance Structure + * The coefficients and state variables for a filter are stored together in an instance data structure. + * A separate instance structure must be defined for each filter. + * Coefficient arrays may be shared among several instances while state variable array should be allocated separately. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Sets the values of the internal structure fields. + * - Zeros out the values in the state buffer. + * - Checks to make sure that the length of the filter is a multiple of the interpolation factor. + * + * \par + * Use of the initialization function is optional. + * However, if the initialization function is used, then the instance structure cannot be placed into a const data section. + * To place an instance structure into a const data section, the instance structure must be manually initialized. + * The code below statically initializes each of the 3 different data type filter instance structures + * 
+ * ne10_fir_interpolate_instance_f32_t S = {L, phaseLength, pCoeffs, pState};
+ *
+ * where L is the interpolation factor; phaseLength=numTaps/L is the + * length of each of the shorter FIR filters used internally, + * pCoeffs is the address of the coefficient buffer; + * pState is the address of the state buffer. + * Be sure to set the values in the state buffer to zeros when doing static initialization. + * + * \par Fixed-Point Behavior + * Care must be taken when using the fixed-point versions of the FIR interpolate filter functions. + * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + +/** + * @addtogroup FIR_Interpolate + * @{ + */ /** * @brief Processing function for the floating-point FIR interpolator. @@ -698,6 +882,83 @@ void ne10_fir_interpolate_float_c (const ne10_fir_interpolate_instance_f32_t * S } } +/** @} */ //end of FIR_interpolate group + + +/** + * @ingroup groupDSPs + */ + +/** + * @defgroup FIR_Lattice Finite Impulse Response (FIR) Lattice Filters + * + * \par + * This set of functions implements Finite Impulse Response (FIR) lattice filters + * for floating-point data types. Lattice filters are used in a + * variety of adaptive filter applications. The filter structure is feedforward and + * the net impulse response is finite length. + * The functions operate on blocks + * of input and output data and each call to the function processes + * blockSize samples through the filter. pSrc and + * pDst point to input and output arrays containing blockSize values. + * + * \par Algorithm: + * \image html FIRLattice.gif "Finite Impulse Response Lattice filter" + * The following difference equation is implemented: + * 
+ *    f0[n] = g0[n] = x[n]
+ *    fm[n] = fm-1[n] + km * gm-1[n-1] for m = 1, 2, ...M
+ *    gm[n] = km * fm-1[n] + gm-1[n-1] for m = 1, 2, ...M
+ *    y[n] = fM[n]
+ *
+ * \par + * pCoeffs points to tha array of reflection coefficients of size numStages. + * Reflection Coefficients are stored in the following order. + * \par + * 
+ *    {k1, k2, ..., kM}
+ *
+ * where M is number of stages + * \par + * pState points to a state array of size numStages. + * The state variables (g values) hold previous inputs and are stored in the following order. + * 
+ *    {g0[n], g1[n], g2[n] ...gM-1[n]}
+ *
+ * The state variables are updated after each block of data is processed; the coefficients are untouched. + * \par Instance Structure + * The coefficients and state variables for a filter are stored together in an instance data structure. + * A separate instance structure must be defined for each filter. + * Coefficient arrays may be shared among several instances while state variable arrays cannot be shared. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Sets the values of the internal structure fields. + * - Zeros out the values in the state buffer. + * + * \par + * Use of the initialization function is optional. + * However, if the initialization function is used, then the instance structure cannot be placed into a const data section. + * To place an instance structure into a const data section, the instance structure must be manually initialized. + * Set the values in the state buffer to zeros and then manually initialize the instance structure as follows: + * 
+ *ne10_iir_lattice_instance_f32_t S = {numStages, pState, pCoeffs};
+ *
+ * \par + * where numStages is the number of stages in the filter; pState is the address of the state buffer; + * pCoeffs is the address of the coefficient buffer. + * \par Fixed-Point Behavior + * Care must be taken when using the fixed-point versions of the FIR Lattice filter functions. + * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered. + * Refer to the function specific documentation below for usage guidelines. + */ + +/** + * @addtogroup FIR_Lattice + * @{ + */ /** * @brief Processing function for the floating-point FIR lattice filter. @@ -1004,10 +1265,11 @@ void ne10_fir_lattice_float_c (const ne10_fir_lattice_instance_f32_t * S, } } -/** - * @brief floating-point Circular write function. - */ +/** @} */ //end of FIR_Lattice group +/** + * @brief floating-point Circular write function. + */ static void ne10_circular_write_float (ne10_int32_t * circBuffer, ne10_int32_t L, ne10_uint16_t * writeOffset, @@ -1102,6 +1364,67 @@ static void ne10_circular_read_float (ne10_int32_t * circBuffer, *readOffset = rOffset; } +/** + * @ingroup groupDSPs + */ + +/** + * @defgroup FIR_Sparse Finite Impulse Response (FIR) Sparse Filters + * + * \par + * This group of functions implements sparse FIR filters. + * Sparse FIR filters are equivalent to standard FIR filters except that most of the coefficients are equal to zero. + * Sparse filters are used for simulating reflections in communications and audio applications. + * + * There are separate functions for floating-point data types. + * The functions operate on blocks of input and output data and each call to the function processes + * blockSize samples through the filter. pSrc and + * pDst points to input and output arrays respectively containing blockSize values. + * + * \par Algorithm: + * The sparse filter instant structure contains an array of tap indices pTapDelay which specifies the locations of the non-zero coefficients. + * This is in addition to the coefficient array b. + * The implementation essentially skips the multiplications by zero and leads to an efficient realization. + * 
+ *     y[n] = b[0] * x[n-pTapDelay[0]] + b[1] * x[n-pTapDelay[1]] + b[2] * x[n-pTapDelay[2]] + ...+ b[numTaps-1] * x[n-pTapDelay[numTaps-1]]
+ *
+ * \par + * \image html FIRSparse.gif "Sparse FIR filter. b[n] represents the filter coefficients" + * \par + * pCoeffs points to a coefficient array of size numTaps; + * pTapDelay points to an array of nonzero indices and is also of size numTaps; + * pState points to a state array of size maxDelay + blockSize, where + * maxDelay is the largest offset value that is ever used in the pTapDelay array. + * Some of the processing functions also require temporary working buffers. + * + * \par Instance Structure + * The coefficients and state variables for a filter are stored together in an instance data structure. + * A separate instance structure must be defined for each filter. + * Coefficient and offset arrays may be shared among several instances while state variable arrays cannot be shared. + * There are separate instance structure declarations for each of the 4 supported data types. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Sets the values of the internal structure fields. + * - Zeros out the values in the state buffer. + * + * \par + * Use of the initialization function is optional. + * However, if the initialization function is used, then the instance structure cannot be placed into a const data section. + * To place an instance structure into a const data section, the instance structure must be manually initialized. + * Set the values in the state buffer to zeros before static initialization. + * The code below statically initializes each of the 4 different data type filter instance structures + * 
+ *ne10_fir_sparse_instance_f32_t S = {numTaps, 0, pState, pCoeffs, maxDelay, pTapDelay};
+ *
+ * + */ + +/** + * @addtogroup FIR_Sparse + * @{ + */ /** * @brief Processing function for the floating-point sparse FIR filter. @@ -1277,8 +1600,5 @@ void ne10_fir_sparse_float_c (ne10_fir_sparse_instance_f32_t * S, } } +/** @} */ //end of FIR_sparse group - -/** - * @} end of FIR group - */ diff --git a/modules/dsp/NE10_iir.c b/modules/dsp/NE10_iir.c index b8c08a8..d886e00 100644 --- a/modules/dsp/NE10_iir.c +++ b/modules/dsp/NE10_iir.c @@ -38,8 +38,9 @@ /** * @defgroup IIR_Lattice Infinite Impulse Response (IIR) Lattice Filters * + * \par * This set of functions implements lattice filters - * for Q15, Q31 and floating-point data types. Lattice filters are used in a + * for and floating-point data types. Lattice filters are used in a * variety of adaptive filter applications. The filter structure has feedforward and * feedback components and the net impulse response is infinite length. * The functions operate on blocks @@ -306,10 +307,4 @@ void ne10_iir_lattice_float_c (const ne10_iir_lattice_instance_f32_t * S, } } - - - - -/** - * @} end of IIR_Lattice group - */ +/** @} */ //end of IIR_Lattice group diff --git a/modules/dsp/NE10_rfft.c b/modules/dsp/NE10_rfft.c index b29cad5..6ad8e20 100644 --- a/modules/dsp/NE10_rfft.c +++ b/modules/dsp/NE10_rfft.c @@ -32,6 +32,84 @@ #include "NE10_types.h" /** + * @ingroup groupDSPs + */ + +/** + * @defgroup RFFT_RIFFT Real FFT + * + * \par + * Complex FFT/IFFT typically assumes complex input and output. However many applications use real valued data in time domain. + * Real FFT/IFFT efficiently process real valued sequences with the advantage of requirement of low memory and with less complexity. + * + * \par + * This set of functions implements Real Fast Fourier Transforms(RFFT) and Real Inverse Fast Fourier Transform(RIFFT) + * for floating-point data types. + * + * + * \par Algorithm: + * + * Real Fast Fourier Transform: + * \par + * Real FFT of N-point is calculated using CFFT of N/2-point and Split RFFT process as shown below figure. + * \par + * \image html RFFT.gif "Real Fast Fourier Transform" + * \par + * The RFFT functions operate on blocks of input and output data and each call to the function processes + * fftLenR samples through the transform. pSrc points to input array containing fftLenR values. + * pDst points to output array containing 2*fftLenR values. \n + * Input for real FFT is in the order of + * 
{real[0], real[1], real[2], real[3], ..}
+ * Output for real FFT is complex and are in the order of + * 
{real(0), imag(0), real(1), imag(1), ...}
+ * + * Real Inverse Fast Fourier Transform: + * \par + * Real IFFT of N-point is calculated using Split RIFFT process and CFFT of N/2-point as shown below figure. + * \par + * \image html RIFFT.gif "Real Inverse Fast Fourier Transform" + * \par + * The RIFFT functions operate on blocks of input and output data and each call to the function processes + * 2*fftLenR samples through the transform. pSrc points to input array containing 2*fftLenR values. + * pDst points to output array containing fftLenR values. \n + * Input for real IFFT is complex and are in the order of + * 
{real(0), imag(0), real(1), imag(1), ...}
+ * Output for real IFFT is real and in the order of + * 
{real[0], real[1], real[2], real[3], ..}
+ * + * \par Lengths supported by the transform: + * \par + * Real FFT/IFFT supports the lengths [128, 512, 2048], as it internally uses CFFT/CIFFT. + * + * \par Instance Structure + * A separate instance structure must be defined for each Instance but the twiddle factors can be reused. + * There are separate instance structure declarations for each of the 3 supported data types. + * + * \par Initialization Functions + * There is also an associated initialization function for each data type. + * The initialization function performs the following operations: + * - Sets the values of the internal structure fields. + * - Initializes twiddle factor tables. + * - Initializes CFFT data structure fields. + * \par + * Use of the initialization function is optional. + * However, if the initialization function is used, then the instance structure cannot be placed into a const data section. + * To place an instance structure into a const data section, the instance structure must be manually initialized. + * Manually initialize the instance structure as follows: + * 
+ *ne10_rfft_instance_f32_t S = {fft_len_real, fft_len_by2, ifft_flag_r, bit_reverse_flag_r, twid_coef_r_modifier, p_twiddle_A_real, p_twiddle_B_real, p_cfft};
+ *
+ * where fft_len_real length of RFFT/RIFFT; fft_len_by2 length of CFFT/CIFFT. + * ifft_flag_r Flag for selection of RFFT or RIFFT(Set ifftFlagR to calculate RIFFT otherwise calculates RFFT); + * bit_reverse_flag_r Flag for selection of output order(Set bitReverseFlagR to output in normal order otherwise output in bit reversed order); + * twid_coef_r_modifier modifier for twiddle factor table which supports 128, 512, 2048 RFFT lengths with same table; + * p_twiddle_A_realpoints to A array of twiddle coefficients; p_twiddle_B_realpoints to B array of twiddle coefficients; + * p_cfft points to the CFFT Instance structure. The CFFT structure also needs to be initialized, refer to arm_cfft_radix4_f32() for details regarding + * static initialization of cfft structure. + * + */ + +/** * @brief Core Real FFT process * @param[in] *pSrc points to the Input buffer * @param[in] N length of Real FFT @@ -164,17 +242,21 @@ static void ne10_split_rifft_float_c( } /** + * @addtogroup RFFT_RIFFT + * @{ + */ + +/** * @brief Real FFT process - * @param *S is an instance for the structure - * @param *pSrc points to the input buffer + * @param[in] *S is an instance for the structure + * @param[in] *pSrc point to the input buffer (out-of-place: it's also a tmp buffer, so the input buffer is destroyed) + * @param[out] *pDst point to the output buffer (out-of-place) + * @param[in] *pTemp point to the temp buffer (used for intermedia buffer) * @return none. * The function implements a Real FFT/ Real IFFT depending * on the direction flag * Can support FFT lengths of 128, 512, 2048 * - * Approximate Cycle Calculation for M4: - * - * C0 + C1 * fftLen */ void ne10_rfft_float_c( const ne10_rfft_instance_f32_t * S, @@ -204,4 +286,6 @@ void ne10_rfft_float_c( } - +/** + * @} end of RFFT_RIFFT group + */ diff --git a/modules/dsp/NE10_rfft.neon.c b/modules/dsp/NE10_rfft.neon.c index a914109..419a971 100644 --- a/modules/dsp/NE10_rfft.neon.c +++ b/modules/dsp/NE10_rfft.neon.c @@ -459,17 +459,21 @@ static void ne10_split_rifft_float_neon( } /** + * @addtogroup RFFT_RIFFT + * @{ + */ + +/** * @brief Real FFT process - * @param *S is an instance for the structure - * @param *pSrc points to the input buffer + * @param[in] *S is an instance for the structure + * @param[in] *pSrc point to the input buffer (out-of-place: it's also a tmp buffer, so the input buffer is destroyed) + * @param[out] *pDst point to the output buffer (out-of-place) + * @param[in] *pTemp point to the temp buffer (used for intermedia buffer) * @return none. * The function implements a Real FFT/ Real IFFT depending * on the direction flag * Can support FFT lengths of 128, 512, 2048 * - * Approximate Cycle Calculation for M4: - * - * C0 + C1 * fftLen */ void ne10_rfft_float_neon( const ne10_rfft_instance_f32_t * S, @@ -498,5 +502,7 @@ void ne10_rfft_float_neon( } } - +/** + * @} end of RFFT_RIFFT group + */ diff --git a/modules/math/NE10_add.c b/modules/math/NE10_add.c index 8a6f537..d08a247 100644 --- a/modules/math/NE10_add.c +++ b/modules/math/NE10_add.c @@ -34,6 +34,7 @@ #include + ne10_result_t ne10_add_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count) { NE10_X_OPERATION_FLOAT_C diff --git a/samples/NE10_test.c b/samples/NE10_test.c index 407fcc3..c4cd81f 100644 --- a/samples/NE10_test.c +++ b/samples/NE10_test.c @@ -24,12 +24,60 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include +#include #include "NE10.h" -#include "NE10_init.h" -// This test code shows you how you can statically embed NE10 in your code +/** + * @ingroup groupSamples + */ +/** + * @addtogroup groupSamples + * @{ + */ +/** + * @brief This test code shows you how to call Ne10 functions with auto detecting NEON hardware + */ +void test_add1 (void) +{ + int i; + ne10_float32_t thesrc[5]; + ne10_float32_t thecst; + ne10_float32_t thedst[5]; + + for (i = 0; i < 5; i++) + { + thesrc[i] = (ne10_float32_t) rand() / RAND_MAX * 5.0f; + } + thecst = (ne10_float32_t) rand() / RAND_MAX * 5.0f; + + ne10_addc_float (thedst , thesrc, thecst, 5); +} + +/** + * @brief This test code shows you how to call Ne10 functions directly + */ +void test_add2 (void) +{ + int i; + ne10_float32_t thesrc[5]; + ne10_float32_t thecst; + ne10_float32_t thedst1[5]; + ne10_float32_t thedst2[5]; + for (i = 0; i < 5; i++) + { + thesrc[i] = (ne10_float32_t) rand() / RAND_MAX * 5.0f; + } + thecst = (ne10_float32_t) rand() / RAND_MAX * 5.0f; + + ne10_addc_float_c (thedst1 , thesrc, thecst, 5); + ne10_addc_float_neon (thedst2 , thesrc, thecst, 5); +} +/** + * @} end of groupSamples + */ void main() { ne10_result_t status; @@ -40,5 +88,7 @@ void main() printf ("NE10 init failed.\n"); printf ("NE10 has been initialized.\n"); + test_add1(); + test_add2(); } -- 2.7.4