beaglert: include/ne10/NE10

annotate include/ne10/NE10_math.h @ 513:485913c58a61 prerelease

removed old readFileTask from libpd

author	Giulio Moro <giuliomoro@yahoo.it>
date	Wed, 22 Jun 2016 04:58:17 +0100
parents	24c3a0663d54
children

rev	line source
andrewm@379	1 /*
andrewm@379	2 * Copyright 2011-15 ARM Limited and Contributors.
andrewm@379	3 * All rights reserved.
andrewm@379	4 *
andrewm@379	5 * Redistribution and use in source and binary forms, with or without
andrewm@379	6 * modification, are permitted provided that the following conditions are met:
andrewm@379	7 * * Redistributions of source code must retain the above copyright
andrewm@379	8 * notice, this list of conditions and the following disclaimer.
andrewm@379	9 * * Redistributions in binary form must reproduce the above copyright
andrewm@379	10 * notice, this list of conditions and the following disclaimer in the
andrewm@379	11 * documentation and/or other materials provided with the distribution.
andrewm@379	12 * * Neither the name of ARM Limited nor the
andrewm@379	13 * names of its contributors may be used to endorse or promote products
andrewm@379	14 * derived from this software without specific prior written permission.
andrewm@379	15 *
andrewm@379	16 * THIS SOFTWARE IS PROVIDED BY ARM LIMITED AND CONTRIBUTORS "AS IS" AND
andrewm@379	17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
andrewm@379	18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
andrewm@379	19 * DISCLAIMED. IN NO EVENT SHALL ARM LIMITED AND CONTRIBUTORS BE LIABLE FOR ANY
andrewm@379	20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
andrewm@379	21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
andrewm@379	22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
andrewm@379	23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
andrewm@379	24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
andrewm@379	25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
andrewm@379	26 */
andrewm@379	27
andrewm@379	28 /*
andrewm@379	29 * NE10 Library : inc/NE10_math.h
andrewm@379	30 */
andrewm@379	31
andrewm@379	32
andrewm@379	33 #include "NE10_types.h"
andrewm@379	34
andrewm@379	35 #ifndef NE10_MATH_H
andrewm@379	36 #define NE10_MATH_H
andrewm@379	37
andrewm@379	38 #ifdef __cplusplus
andrewm@379	39 extern "C" {
andrewm@379	40 #endif
andrewm@379	41
andrewm@379	42 ///////////////////////////
andrewm@379	43 // function prototypes:
andrewm@379	44 ///////////////////////////
andrewm@379	45
andrewm@379	46
andrewm@379	47 // ## Vector-Constant Arithmetic ##
andrewm@379	48
andrewm@379	49 /**
andrewm@379	50 * @ingroup groupMaths
andrewm@379	51 */
andrewm@379	52
andrewm@379	53 /**
andrewm@379	54 * @defgroup ADD_VEC Vector Add
andrewm@379	55 *
andrewm@379	56 * \par
andrewm@379	57 * These functions implement the vector add operation for float data type.
andrewm@379	58 */
andrewm@379	59
andrewm@379	60 /**
andrewm@379	61 * @addtogroup ADD_VEC
andrewm@379	62 * @{
andrewm@379	63 */
andrewm@379	64
andrewm@379	65 /**
andrewm@379	66 * Adds a constant scalar value to all the elements of an input array and stores the results in an output array.
andrewm@379	67 * This function point could be pointed to one of ne10_addc_float_c, ne10_addc_float_neon and ne10_addc_float_asm.
andrewm@379	68 * @param[out] dst Pointer to the destination array
andrewm@379	69 * @param[in] src Pointer to the source array
andrewm@379	70 * @param[in] cst The constant scalar added to the input values
andrewm@379	71 * @param[in] count The number of items in the input array
andrewm@379	72 */
andrewm@379	73 extern ne10_result_t (ne10_addc_float) (ne10_float32_t dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	74 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);
andrewm@379	75 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) asm ("ne10_addc_float_neon");
andrewm@379	76 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);
andrewm@379	77 /**
andrewm@379	78 * Adds a constant 2D vector to all of the vectors in an input array and stores the results in an output array.
andrewm@379	79 * This function point could be pointed to one of ne10_addc_vec2f_c, ne10_addc_vec2f_neon and ne10_addc_vec2f_asm.
andrewm@379	80 * @param[out] dst Pointer to the destination array
andrewm@379	81 * @param[in] src Pointer to the source array
andrewm@379	82 * @param[in] cst Pointer to the 2D vector added to the input values
andrewm@379	83 * @param[in] count The number of items in the input array
andrewm@379	84 */
andrewm@379	85 extern ne10_result_t (ne10_addc_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	86 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);
andrewm@379	87 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) asm ("ne10_addc_vec2f_neon");
andrewm@379	88 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);
andrewm@379	89 /**
andrewm@379	90 * Adds a constant 3D vector to all of the vectors in an input array and stores the results in an output array.
andrewm@379	91 * This function point could be pointed to one of ne10_addc_vec3f_c, ne10_addc_vec3f_neon and ne10_addc_vec3f_asm.
andrewm@379	92 * @param[out] dst Pointer to the destination array
andrewm@379	93 * @param[in] src Pointer to the source array
andrewm@379	94 * @param[in] cst Pointer to the 3D vector added to the input values
andrewm@379	95 * @param[in] count The number of items in the input array
andrewm@379	96 */
andrewm@379	97 extern ne10_result_t (ne10_addc_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	98 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);
andrewm@379	99 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) asm ("ne10_addc_vec3f_neon");
andrewm@379	100 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);
andrewm@379	101 /**
andrewm@379	102 * Adds a constant 4D vector to all of the vectors in an input array and stores the results in an output array.
andrewm@379	103 * This function point could be pointed to one of ne10_addc_vec4f_c, ne10_addc_vec4f_neon and ne10_addc_vec4f_asm.
andrewm@379	104 * @param[out] dst Pointer to the destination array
andrewm@379	105 * @param[in] src Pointer to the source array
andrewm@379	106 * @param[in] cst Pointer to the 4D vector added to the input values
andrewm@379	107 * @param[in] count The number of items in the input array
andrewm@379	108 */
andrewm@379	109 extern ne10_result_t (ne10_addc_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	110 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);
andrewm@379	111 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) asm ("ne10_addc_vec4f_neon");
andrewm@379	112 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);
andrewm@379	113
andrewm@379	114
andrewm@379	115 /**
andrewm@379	116 * Adds the elements of src1 to the elements of src2 and stores the results in the dst.
andrewm@379	117 * This function point could be pointed to one of ne10_add_float_c, ne10_add_float_neon and ne10_add_float_asm.
andrewm@379	118 * @param[out] dst Pointer to the destination array
andrewm@379	119 * @param[in] src1 The first array to use as the input array
andrewm@379	120 * @param[in] src2 The second array to use as the input array
andrewm@379	121 * @param[in] count The number of items in the two input arrays
andrewm@379	122 */
andrewm@379	123 extern ne10_result_t (ne10_add_float) (ne10_float32_t dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	124 extern ne10_result_t ne10_add_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	125 extern ne10_result_t ne10_add_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count) asm ("ne10_add_float_neon");
andrewm@379	126 extern ne10_result_t ne10_add_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	127 /**
andrewm@379	128 * Vector addition of two 2D vectors.
andrewm@379	129 * This function point could be pointed to one of ne10_add_vec2f_c, ne10_add_vec2f_neon and ne10_add_vec2f_asm.
andrewm@379	130 * @param[out] dst Pointer to the destination array
andrewm@379	131 * @param[in] src1 Pointer to the first source array
andrewm@379	132 * @param[in] src2 Pointer to the second source array
andrewm@379	133 * @param[in] count The number of items in the input arrays
andrewm@379	134 */
andrewm@379	135 extern ne10_result_t (ne10_add_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	136 extern ne10_result_t ne10_add_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	137 extern ne10_result_t ne10_add_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count) asm ("ne10_add_vec2f_neon");
andrewm@379	138 extern ne10_result_t ne10_add_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	139 /**
andrewm@379	140 * Vector addition of two 3D vectors.
andrewm@379	141 * This function point could be pointed to one of ne10_add_vec3f_c, ne10_add_vec3f_neon and ne10_add_vec3f_asm.
andrewm@379	142 * @param[out] dst Pointer to the destination array
andrewm@379	143 * @param[in] src1 Pointer to the first source array
andrewm@379	144 * @param[in] src2 Pointer to the second source array
andrewm@379	145 * @param[in] count The number of items in the input arrays
andrewm@379	146 */
andrewm@379	147 extern ne10_result_t (ne10_add_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	148 extern ne10_result_t ne10_add_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	149 extern ne10_result_t ne10_add_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count) asm ("ne10_add_vec3f_neon");
andrewm@379	150 extern ne10_result_t ne10_add_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	151 /**
andrewm@379	152 * Vector addition of two 4D vectors.
andrewm@379	153 * This function point could be pointed to one of ne10_add_vec4f_c, ne10_add_vec4f_neon and ne10_add_vec4f_asm.
andrewm@379	154 * @param[out] dst Pointer to the destination array
andrewm@379	155 * @param[in] src1 Pointer to the first source array
andrewm@379	156 * @param[in] src2 Pointer to the second source array
andrewm@379	157 * @param[in] count The number of items in the input arrays
andrewm@379	158 */
andrewm@379	159 extern ne10_result_t (ne10_add_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	160 extern ne10_result_t ne10_add_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	161 extern ne10_result_t ne10_add_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count) asm ("ne10_add_vec4f_neon");
andrewm@379	162 extern ne10_result_t ne10_add_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	163 /** @} */ //end of Vector Add group
andrewm@379	164
andrewm@379	165 /**
andrewm@379	166 * @ingroup groupMaths
andrewm@379	167 */
andrewm@379	168
andrewm@379	169 /**
andrewm@379	170 * @defgroup ADD_MAT Matrix Add
andrewm@379	171 *
andrewm@379	172 * \par
andrewm@379	173 * These functions implement the matrix add operation for float data type.
andrewm@379	174 */
andrewm@379	175
andrewm@379	176 /**
andrewm@379	177 * @addtogroup ADD_MAT
andrewm@379	178 * @{
andrewm@379	179 */
andrewm@379	180
andrewm@379	181 /**
andrewm@379	182 * Vector addition of two 4x4 matrixs.
andrewm@379	183 * This function point could be pointed to one of ne10_addmat_4x4f_c, ne10_addmat_4x4f_neon and ne10_addmat_4x4f_asm.
andrewm@379	184 * @param[out] dst Pointer to the destination array
andrewm@379	185 * @param[in] src1 Pointer to the first source array
andrewm@379	186 * @param[in] src2 Pointer to the second source array
andrewm@379	187 * @param[in] count The number of items in the input arrays
andrewm@379	188 */
andrewm@379	189 extern ne10_result_t (ne10_addmat_4x4f) (ne10_mat4x4f_t dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	190 extern ne10_result_t ne10_addmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	191 extern ne10_result_t ne10_addmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	192 extern ne10_result_t ne10_addmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	193 /**
andrewm@379	194 * Vector addition of two 3x3 matrixs.
andrewm@379	195 * This function point could be pointed to one of ne10_addmat_3x3f_c, ne10_addmat_3x3f_neon and ne10_addmat_3x3f_asm.
andrewm@379	196 * @param[out] dst Pointer to the destination array
andrewm@379	197 * @param[in] src1 Pointer to the first source array
andrewm@379	198 * @param[in] src2 Pointer to the second source array
andrewm@379	199 * @param[in] count The number of items in the input arrays
andrewm@379	200 */
andrewm@379	201 extern ne10_result_t (ne10_addmat_3x3f) (ne10_mat3x3f_t dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	202 extern ne10_result_t ne10_addmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	203 extern ne10_result_t ne10_addmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	204 extern ne10_result_t ne10_addmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	205 /**
andrewm@379	206 * Vector addition of two 2x2 matrixs.
andrewm@379	207 * This function point could be pointed to one of ne10_addmat_2x2f_c, ne10_addmat_2x2f_neon and ne10_addmat_2x2f_asm.
andrewm@379	208 * @param[out] dst Pointer to the destination array
andrewm@379	209 * @param[in] src1 Pointer to the first source array
andrewm@379	210 * @param[in] src2 Pointer to the second source array
andrewm@379	211 * @param[in] count The number of items in the input arrays
andrewm@379	212 */
andrewm@379	213 extern ne10_result_t (ne10_addmat_2x2f) (ne10_mat2x2f_t dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	214 extern ne10_result_t ne10_addmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	215 extern ne10_result_t ne10_addmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	216 extern ne10_result_t ne10_addmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	217 /** @} */ //end of Matrix Add group
andrewm@379	218
andrewm@379	219
andrewm@379	220 /**
andrewm@379	221 * @ingroup groupMaths
andrewm@379	222 */
andrewm@379	223
andrewm@379	224 /**
andrewm@379	225 * @defgroup SUB_VEC Vector Sub
andrewm@379	226 *
andrewm@379	227 * \par
andrewm@379	228 * These functions implement the vector sub operation for float data type.
andrewm@379	229 */
andrewm@379	230
andrewm@379	231 /**
andrewm@379	232 * @addtogroup SUB_VEC
andrewm@379	233 * @{
andrewm@379	234 */
andrewm@379	235
andrewm@379	236 /**
andrewm@379	237 * Subtracts a constant scalar from all the elements of an input array and stores the results in an output array.
andrewm@379	238 * This function point could be pointed to one of ne10_subc_float_c, ne10_subc_float_neon and ne10_subc_float_asm.
andrewm@379	239 * @param[out] dst Pointer to the destination array
andrewm@379	240 * @param[in] src Pointer to the source array
andrewm@379	241 * @param[in] cst The constant scalar subtracted from the input values
andrewm@379	242 * @param[in] count The number of items in the input array
andrewm@379	243 */
andrewm@379	244 extern ne10_result_t (ne10_subc_float) (ne10_float32_t dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	245 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)
andrewm@379	246 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)
andrewm@379	247 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)
andrewm@379	248 /**
andrewm@379	249 * Subtracts a constant 2D vector from all of the vectors in an input array and stores the results in an output array.
andrewm@379	250 * This function point could be pointed to one of ne10_subc_vec2f_c, ne10_subc_vec2f_neon and ne10_subc_vec2f_asm.
andrewm@379	251 * @param[out] dst Pointer to the destination array
andrewm@379	252 * @param[in] src Pointer to the source array
andrewm@379	253 * @param[in] cst Pointer to the 2D vector subtracted from the input values
andrewm@379	254 * @param[in] count The number of items in the input array
andrewm@379	255 */
andrewm@379	256 extern ne10_result_t (ne10_subc_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	257 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)
andrewm@379	258 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)
andrewm@379	259 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)
andrewm@379	260 /**
andrewm@379	261 * Subtracts a constant 3D vector from all of the vectors in an input array and stores the results in an output array.
andrewm@379	262 * This function point could be pointed to one of ne10_subc_vec3f_c, ne10_subc_vec3f_neon and ne10_subc_vec3f_asm.
andrewm@379	263 * @param[out] dst Pointer to the destination array
andrewm@379	264 * @param[in] src Pointer to the source array
andrewm@379	265 * @param[in] cst Pointer to the 3D vector subtracted from the input values
andrewm@379	266 * @param[in] count The number of items in the input array
andrewm@379	267 */
andrewm@379	268 extern ne10_result_t (ne10_subc_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	269 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)
andrewm@379	270 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)
andrewm@379	271 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)
andrewm@379	272 /**
andrewm@379	273 * Subtracts a constant 4D vector from all of the vectors in an input array and stores the results in an output array.
andrewm@379	274 * This function point could be pointed to one of ne10_subc_vec4f_c, ne10_subc_vec4f_neon and ne10_subc_vec4f_asm.
andrewm@379	275 * @param[out] dst Pointer to the destination array
andrewm@379	276 * @param[in] src Pointer to the source array
andrewm@379	277 * @param[in] cst Pointer to the 4D vector subtracted from the input values
andrewm@379	278 * @param[in] count The number of items in the input array
andrewm@379	279 */
andrewm@379	280 extern ne10_result_t (ne10_subc_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	281 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)
andrewm@379	282 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)
andrewm@379	283 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)
andrewm@379	284
andrewm@379	285 /**
andrewm@379	286 * Subtracts the elements of src2 from the elements of src1 and stores the results in the dst.
andrewm@379	287 * This function point could be pointed to one of ne10_sub_float_c, ne10_sub_float_neon and ne10_sub_float_asm.
andrewm@379	288 * @param[out] dst Pointer to the destination array
andrewm@379	289 * @param[in] src1 The first array to use as the input array
andrewm@379	290 * @param[in] src2 The second array to use as the input array
andrewm@379	291 * @param[in] count The number of items in the two input arrays
andrewm@379	292 */
andrewm@379	293 extern ne10_result_t (ne10_sub_float) (ne10_float32_t dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	294 extern ne10_result_t ne10_sub_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	295 extern ne10_result_t ne10_sub_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count) asm ("ne10_sub_float_neon");
andrewm@379	296 extern ne10_result_t ne10_sub_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	297 /**
andrewm@379	298 * Vector subtraction of two 2D vectors.
andrewm@379	299 * This function point could be pointed to one of ne10_sub_vec2f_c, ne10_sub_vec2f_neon and ne10_sub_vec2f_asm.
andrewm@379	300 * @param[out] dst Pointer to the destination array
andrewm@379	301 * @param[in] src1 Pointer to the first source array
andrewm@379	302 * @param[in] src2 Pointer to the second source array
andrewm@379	303 * @param[in] count The number of items in the input arrays
andrewm@379	304 */
andrewm@379	305 extern ne10_result_t (ne10_sub_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	306 extern ne10_result_t ne10_sub_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	307 extern ne10_result_t ne10_sub_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count) asm ("ne10_sub_vec2f_neon");
andrewm@379	308 extern ne10_result_t ne10_sub_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	309 /**
andrewm@379	310 * Vector subtraction of two 3D vectors.
andrewm@379	311 * This function point could be pointed to one of ne10_sub_vec3f_c, ne10_sub_vec3f_neon and ne10_sub_vec3f_asm.
andrewm@379	312 * @param[out] dst Pointer to the destination array
andrewm@379	313 * @param[in] src1 Pointer to the first source array
andrewm@379	314 * @param[in] src2 Pointer to the second source array
andrewm@379	315 * @param[in] count The number of items in the input arrays
andrewm@379	316 */
andrewm@379	317 extern ne10_result_t (ne10_sub_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	318 extern ne10_result_t ne10_sub_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	319 extern ne10_result_t ne10_sub_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count) asm ("ne10_sub_vec3f_neon");
andrewm@379	320 extern ne10_result_t ne10_sub_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	321 /**
andrewm@379	322 * Vector subtraction of two 4D vectors.
andrewm@379	323 * This function point could be pointed to one of ne10_sub_vec4f_c, ne10_sub_vec4f_neon and ne10_sub_vec4f_asm.
andrewm@379	324 * @param[out] dst Pointer to the destination array
andrewm@379	325 * @param[in] src1 Pointer to the first source array
andrewm@379	326 * @param[in] src2 Pointer to the second source array
andrewm@379	327 * @param[in] count The number of items in the input arrays
andrewm@379	328 */
andrewm@379	329 extern ne10_result_t (ne10_sub_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	330 extern ne10_result_t ne10_sub_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	331 extern ne10_result_t ne10_sub_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count) asm ("ne10_sub_vec4f_neon");
andrewm@379	332 extern ne10_result_t ne10_sub_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	333 /** @} */ //end of Vector Sub group
andrewm@379	334
andrewm@379	335 /**
andrewm@379	336 * @ingroup groupMaths
andrewm@379	337 */
andrewm@379	338
andrewm@379	339 /**
andrewm@379	340 * @defgroup RSBC Vector Rsbc
andrewm@379	341 *
andrewm@379	342 * \par
andrewm@379	343 * These functions implement the vector rsbc operation for float data type.
andrewm@379	344 */
andrewm@379	345
andrewm@379	346 /**
andrewm@379	347 * @addtogroup RSBC
andrewm@379	348 * @{
andrewm@379	349 */
andrewm@379	350 /**
andrewm@379	351 * Subtracts the elements of an input array from a constant scalar and stores the results in an output array.
andrewm@379	352 * This function point could be pointed to one of ne10_rsbc_float_c, ne10_rsbc_float_neon and ne10_rsbc_float_asm.
andrewm@379	353 * @param[out] dst Pointer to the destination array
andrewm@379	354 * @param[in] src Pointer to the source array
andrewm@379	355 * @param[in] cst The constant scalar to subtract the input values from
andrewm@379	356 * @param[in] count The number of items in the input array
andrewm@379	357 */
andrewm@379	358 extern ne10_result_t (ne10_rsbc_float) (ne10_float32_t dst, ne10_float32_t *src, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	359 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
andrewm@379	360 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
andrewm@379	361 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
andrewm@379	362 /**
andrewm@379	363 * Subtracts the vectors in an input array from a constant 2D vector and stores the results in an output array.
andrewm@379	364 * This function point could be pointed to one of ne10_rsbc_vec2f_c, ne10_rsbc_vec2f_neon and ne10_rsbc_vec2f_asm.
andrewm@379	365 * @param[out] dst Pointer to the destination array
andrewm@379	366 * @param[in] src Pointer to the source array
andrewm@379	367 * @param[in] cst Pointer to the 2D vector to subtract the input values from
andrewm@379	368 * @param[in] count The number of items in the input array
andrewm@379	369 */
andrewm@379	370 extern ne10_result_t (ne10_rsbc_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	371 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
andrewm@379	372 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
andrewm@379	373 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
andrewm@379	374 /**
andrewm@379	375 * Subtracts the vectors in an input array from a constant 3D vector and stores the results in an output array.
andrewm@379	376 * This function point could be pointed to one of ne10_rsbc_vec3f_c, ne10_rsbc_vec3f_neon and ne10_rsbc_vec3f_asm.
andrewm@379	377 * @param[out] dst Pointer to the destination array
andrewm@379	378 * @param[in] src Pointer to the source array
andrewm@379	379 * @param[in] cst Pointer to the 3D vector to subtract the input values from
andrewm@379	380 * @param[in] count The number of items in the input array
andrewm@379	381 */
andrewm@379	382 extern ne10_result_t (ne10_rsbc_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	383 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
andrewm@379	384 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
andrewm@379	385 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
andrewm@379	386 /**
andrewm@379	387 * Subtracts the vectors in an input array from a constant 4D vector and stores the results in an output array.
andrewm@379	388 * This function point could be pointed to one of ne10_rsbc_vec4f_c, ne10_rsbc_vec4f_neon and ne10_rsbc_vec4f_asm.
andrewm@379	389 * @param[out] dst Pointer to the destination array
andrewm@379	390 * @param[in] src Pointer to the source array
andrewm@379	391 * @param[in] cst Pointer to the 4D vector to subtract the input values from
andrewm@379	392 * @param[in] count The number of items in the input array
andrewm@379	393 */
andrewm@379	394 extern ne10_result_t (ne10_rsbc_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	395 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
andrewm@379	396 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
andrewm@379	397 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
andrewm@379	398 /** @} */ //end of Vector RSBC group
andrewm@379	399
andrewm@379	400 /**
andrewm@379	401 * @ingroup groupMaths
andrewm@379	402 */
andrewm@379	403
andrewm@379	404 /**
andrewm@379	405 * @defgroup SUB_MAT Matrix Sub
andrewm@379	406 *
andrewm@379	407 * \par
andrewm@379	408 * These functions implement the matrix sub operation for float data type.
andrewm@379	409 */
andrewm@379	410
andrewm@379	411 /**
andrewm@379	412 * @addtogroup SUB_MAT
andrewm@379	413 * @{
andrewm@379	414 */
andrewm@379	415 /**
andrewm@379	416 * Matrix subtraction of two 4x4 matrixs.
andrewm@379	417 * This function point could be pointed to one of ne10_submat_4x4f_c, ne10_submat_4x4f_neon and ne10_submat_4x4f_asm.
andrewm@379	418 * @param[out] dst Pointer to the destination array
andrewm@379	419 * @param[in] src1 Pointer to the first source array
andrewm@379	420 * @param[in] src2 Pointer to the second source array
andrewm@379	421 * @param[in] count The number of items in the input arrays
andrewm@379	422 */
andrewm@379	423 extern ne10_result_t (ne10_submat_4x4f) (ne10_mat4x4f_t dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	424 extern ne10_result_t ne10_submat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	425 extern ne10_result_t ne10_submat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	426 extern ne10_result_t ne10_submat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	427
andrewm@379	428 /**
andrewm@379	429 * Matrix subtraction of two 3x3 matrixs.
andrewm@379	430 * This function point could be pointed to one of ne10_submat_3x3f_c, ne10_submat_3x3f_neon and ne10_submat_3x3f_asm.
andrewm@379	431 * @param[out] dst Pointer to the destination array
andrewm@379	432 * @param[in] src1 Pointer to the first source array
andrewm@379	433 * @param[in] src2 Pointer to the second source array
andrewm@379	434 * @param[in] count The number of items in the input arrays
andrewm@379	435 */
andrewm@379	436 extern ne10_result_t (ne10_submat_3x3f) (ne10_mat3x3f_t dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	437 extern ne10_result_t ne10_submat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	438 extern ne10_result_t ne10_submat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	439 extern ne10_result_t ne10_submat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	440
andrewm@379	441 /**
andrewm@379	442 * Matrix subtraction of two 2x2 matrixs.
andrewm@379	443 * This function point could be pointed to one of ne10_submat_2x2f_c, ne10_submat_2x2f_neon and ne10_submat_2x2f_asm.
andrewm@379	444 * @param[out] dst Pointer to the destination array
andrewm@379	445 * @param[in] src1 Pointer to the first source array
andrewm@379	446 * @param[in] src2 Pointer to the second source array
andrewm@379	447 * @param[in] count The number of items in the input arrays
andrewm@379	448 */
andrewm@379	449 extern ne10_result_t (ne10_submat_2x2f) (ne10_mat2x2f_t dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	450 extern ne10_result_t ne10_submat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	451 extern ne10_result_t ne10_submat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	452 extern ne10_result_t ne10_submat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	453 /** @} */ //end of Matrix Sub group
andrewm@379	454
andrewm@379	455 /**
andrewm@379	456 * @ingroup groupMaths
andrewm@379	457 */
andrewm@379	458
andrewm@379	459 /**
andrewm@379	460 * @defgroup MUL_VEC Vector Multiply
andrewm@379	461 *
andrewm@379	462 * \par
andrewm@379	463 * These functions implement the vector multiply operation for float data type.
andrewm@379	464 */
andrewm@379	465
andrewm@379	466 /**
andrewm@379	467 * @addtogroup MUL_VEC
andrewm@379	468 * @{
andrewm@379	469 */
andrewm@379	470
andrewm@379	471 /**
andrewm@379	472 * Multiplies the elements of an input array by a constant scalar and stores the results in an output array.
andrewm@379	473 * This function point could be pointed to one of ne10_mulc_float_c, ne10_mulc_float_neon and ne10_mulc_float_asm.
andrewm@379	474 * @param[out] dst Pointer to the destination array
andrewm@379	475 * @param[in] src Pointer to the source array
andrewm@379	476 * @param[in] cst The constant scalar to multiply the input values with
andrewm@379	477 * @param[in] count The number of items in the input array
andrewm@379	478 */
andrewm@379	479 extern ne10_result_t (ne10_mulc_float) (ne10_float32_t dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	480 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);
andrewm@379	481 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);
andrewm@379	482 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);
andrewm@379	483 /**
andrewm@379	484 * 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.
andrewm@379	485 * This function point could be pointed to one of ne10_mulc_vec2f_c, ne10_mulc_vec2f_neon and ne10_mulc_vec2f_asm.
andrewm@379	486 * @param[out] dst Pointer to the destination array
andrewm@379	487 * @param[in] src Pointer to the source array
andrewm@379	488 * @param[in] cst Pointer to the 2D vector to multiply the input values with
andrewm@379	489 * @param[in] count The number of items in the input array
andrewm@379	490 */
andrewm@379	491 extern ne10_result_t (ne10_mulc_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	492 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);
andrewm@379	493 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);
andrewm@379	494 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);
andrewm@379	495 /**
andrewm@379	496 * 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.
andrewm@379	497 * This function point could be pointed to one of ne10_mulc_vec3f_c, ne10_mulc_vec3f_neon and ne10_mulc_vec3f_asm.
andrewm@379	498 * @param[out] dst Pointer to the destination array
andrewm@379	499 * @param[in] src Pointer to the source array
andrewm@379	500 * @param[in] cst Pointer to the 3D vector to multiply the input values with
andrewm@379	501 * @param[in] count The number of items in the input array
andrewm@379	502 */
andrewm@379	503 extern ne10_result_t (ne10_mulc_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	504 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);
andrewm@379	505 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);
andrewm@379	506 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);
andrewm@379	507 /**
andrewm@379	508 * 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.
andrewm@379	509 * This function point could be pointed to one of ne10_mulc_vec4f_c, ne10_mulc_vec4f_neon and ne10_mulc_vec4f_asm.
andrewm@379	510 * @param[out] dst Pointer to the destination array
andrewm@379	511 * @param[in] src Pointer to the source array
andrewm@379	512 * @param[in] cst Pointer to the 4D vector to multiply the input values with
andrewm@379	513 * @param[in] count The number of items in the input array
andrewm@379	514 */
andrewm@379	515 extern ne10_result_t (ne10_mulc_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	516 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);
andrewm@379	517 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);
andrewm@379	518 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);
andrewm@379	519
andrewm@379	520 /**
andrewm@379	521 * Multiplies the elements of src1 by the elements of src2 and stores the results in the dst.
andrewm@379	522 * This function point could be pointed to one of ne10_mul_float_c, ne10_mul_float_neon and ne10_mul_float_asm.
andrewm@379	523 * @param[out] dst Pointer to the destination array
andrewm@379	524 * @param[in] src1 The first array to use as the input array
andrewm@379	525 * @param[in] src2 The second array to use as the input array
andrewm@379	526 * @param[in] count The number of items in the two input arrays
andrewm@379	527 */
andrewm@379	528 extern ne10_result_t (ne10_mul_float) (ne10_float32_t dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	529 extern ne10_result_t ne10_mul_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	530 extern ne10_result_t ne10_mul_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count) asm ("ne10_mul_float_neon");
andrewm@379	531 extern ne10_result_t ne10_mul_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	532 /**
andrewm@379	533 * Multiplies the components of a 2D vector with the corresponding components of another.
andrewm@379	534 * This function point could be pointed to one of ne10_vmul_vec2f_c, ne10_vmul_vec2f_neon and ne10_vmul_vec2f_asm.
andrewm@379	535 * @param[out] dst Pointer to the destination array
andrewm@379	536 * @param[in] src1 Pointer to the first source array
andrewm@379	537 * @param[in] src2 Pointer to the second source array
andrewm@379	538 * @param[in] count The number of items in the input arrays
andrewm@379	539 */
andrewm@379	540 extern ne10_result_t (ne10_vmul_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	541 extern ne10_result_t ne10_vmul_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	542 extern ne10_result_t ne10_vmul_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count) asm ("ne10_vmul_vec2f_neon");
andrewm@379	543 extern ne10_result_t ne10_vmul_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	544 /**
andrewm@379	545 * Multiplies the components of a 3D vector with the corresponding components of another.
andrewm@379	546 * This function point could be pointed to one of ne10_vmul_vec3f_c, ne10_vmul_vec3f_neon and ne10_vmul_vec3f_asm.
andrewm@379	547 * @param[out] dst Pointer to the destination array
andrewm@379	548 * @param[in] src1 Pointer to the first source array
andrewm@379	549 * @param[in] src2 Pointer to the second source array
andrewm@379	550 * @param[in] count The number of items in the input arrays
andrewm@379	551 */
andrewm@379	552 extern ne10_result_t (ne10_vmul_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	553 extern ne10_result_t ne10_vmul_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	554 extern ne10_result_t ne10_vmul_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count) asm ("ne10_vmul_vec3f_neon");
andrewm@379	555 extern ne10_result_t ne10_vmul_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	556 /**
andrewm@379	557 * Multiplies the components of a 4D vector with the corresponding components of another.
andrewm@379	558 * This function point could be pointed to one of ne10_vmul_vec4f_c, ne10_vmul_vec4f_neon and ne10_vmul_vec4f_asm.
andrewm@379	559 * @param[out] dst Pointer to the destination array
andrewm@379	560 * @param[in] src1 Pointer to the first source array
andrewm@379	561 * @param[in] src2 Pointer to the second source array
andrewm@379	562 * @param[in] count The number of items in the input arrays
andrewm@379	563 */
andrewm@379	564 extern ne10_result_t (ne10_vmul_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	565 extern ne10_result_t ne10_vmul_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	566 extern ne10_result_t ne10_vmul_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count) asm ("ne10_vmul_vec4f_neon");
andrewm@379	567 extern ne10_result_t ne10_vmul_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	568 /** @} */ //end of Vector Multiply group
andrewm@379	569
andrewm@379	570 /**
andrewm@379	571 * @ingroup groupMaths
andrewm@379	572 */
andrewm@379	573
andrewm@379	574 /**
andrewm@379	575 * @defgroup MLA_VEC Vector Multiply-Accumulator
andrewm@379	576 *
andrewm@379	577 * \par
andrewm@379	578 * These functions implement the vector multiply-accumulator operation for float data type.
andrewm@379	579 */
andrewm@379	580
andrewm@379	581 /**
andrewm@379	582 * @addtogroup MLA_VEC
andrewm@379	583 * @{
andrewm@379	584 */
andrewm@379	585
andrewm@379	586 /**
andrewm@379	587 * Multiplies each entry in the source array (src) by cst, then adds the result to
andrewm@379	588 * the corresponding item of the accumulation array (acc), and stores the result in the destination array.
andrewm@379	589 * This function point could be pointed to one of ne10_mlac_float_c, ne10_mlac_float_neon and ne10_mlac_float_asm.
andrewm@379	590 * @param[out] dst Pointer to the destination array
andrewm@379	591 * @param[in] acc The corresponding elemetn is added to the result of the multiplication
andrewm@379	592 * @param[in] src Pointer to the source array
andrewm@379	593 * @param[in] cst The constant scalar to multiply the input elements with
andrewm@379	594 * @param[in] count The number of items in the input array
andrewm@379	595 */
andrewm@379	596 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);
andrewm@379	597 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);
andrewm@379	598 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);
andrewm@379	599 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);
andrewm@379	600 /**
andrewm@379	601 * Multiplies each entry in the source array (src) by the 2D vector cst, then adds the result to
andrewm@379	602 * the corresponding item of the accumulation array (acc), and stores the result in the destination array.
andrewm@379	603 * This function point could be pointed to one of ne10_mlac_vec2f_c, ne10_mlac_vec2f_neon and ne10_mlac_vec2f_asm.
andrewm@379	604 * @param[out] dst Pointer to the destination array
andrewm@379	605 * @param[in] acc The corresponding elemetn is added to the result of the multiplication
andrewm@379	606 * @param[in] src Pointer to the source array
andrewm@379	607 * @param[in] cst Pointer to the 2D vector to multiply the input vectors with
andrewm@379	608 * @param[in] count The number of items in the input array
andrewm@379	609 */
andrewm@379	610 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);
andrewm@379	611 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);
andrewm@379	612 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);
andrewm@379	613 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);
andrewm@379	614 /**
andrewm@379	615 * Multiplies each entry in the source array (src) by the 3D vector cst, then adds the result to
andrewm@379	616 * the corresponding item of the accumulation array (acc), and stores the result in the destination array.
andrewm@379	617 * This function point could be pointed to one of ne10_mlac_vec3f_c, ne10_mlac_vec3f_neon and ne10_mlac_vec3f_asm.
andrewm@379	618 * @param[out] dst Pointer to the destination array
andrewm@379	619 * @param[in] acc The corresponding elemetn is added to the result of the multiplication
andrewm@379	620 * @param[in] src Pointer to the source array
andrewm@379	621 * @param[in] cst Pointer to the 3D vector to multiply the input vectors with
andrewm@379	622 * @param[in] count The number of items in the input array
andrewm@379	623 */
andrewm@379	624 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);
andrewm@379	625 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);
andrewm@379	626 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);
andrewm@379	627 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);
andrewm@379	628 /**
andrewm@379	629 * Multiplies each entry in the source array (src) by the 4D vector cst, then adds the result to
andrewm@379	630 * the corresponding item of the accumulation array (acc), and stores the result in the destination array.
andrewm@379	631 * This function point could be pointed to one of ne10_mlac_vec4f_c, ne10_mlac_vec4f_neon and ne10_mlac_vec4f_asm.
andrewm@379	632 * @param[out] dst Pointer to the destination array
andrewm@379	633 * @param[in] acc The corresponding elemetn is added to the result of the multiplication
andrewm@379	634 * @param[in] src Pointer to the source array
andrewm@379	635 * @param[in] cst Pointer to the 4D vector to multiply the input vectors with
andrewm@379	636 * @param[in] count The number of items in the input array
andrewm@379	637 */
andrewm@379	638 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);
andrewm@379	639 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);
andrewm@379	640 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);
andrewm@379	641 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);
andrewm@379	642
andrewm@379	643 /**
andrewm@379	644 * Performs a multiply and accumulate operation using the corresponding elements in acc, src1, and src2.
andrewm@379	645 * This function point could be pointed to one of ne10_mla_float_c, ne10_mla_float_neon and ne10_mla_float_asm.
andrewm@379	646 * @param[out] dst Pointer to the destination array
andrewm@379	647 * @param[in] acc These elemtns are added to the result of the multiplication operation
andrewm@379	648 * @param[in] src1 The first array to use as the input array
andrewm@379	649 * @param[in] src2 The second array to use as the input array
andrewm@379	650 * @param[in] count The number of items in the two input arrays
andrewm@379	651 */
andrewm@379	652 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);
andrewm@379	653 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);
andrewm@379	654 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) asm ("ne10_mla_float_neon");
andrewm@379	655 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);
andrewm@379	656 /**
andrewm@379	657 * Performs a multiply and accumulate operation on the components of a 2D vector with the corresponding components of another.
andrewm@379	658 * This function point could be pointed to one of ne10_vmla_vec2f_c, ne10_vmla_vec2f_neon and ne10_vmla_vec2f_asm.
andrewm@379	659 * @param[out] dst Pointer to the destination array
andrewm@379	660 * @param[in] src1 Pointer to the first source array
andrewm@379	661 * @param[in] src2 Pointer to the second source array
andrewm@379	662 * @param[in] count The number of items in the input arrays
andrewm@379	663 */
andrewm@379	664 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);
andrewm@379	665 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);
andrewm@379	666 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) asm ("ne10_vmla_vec2f_neon");
andrewm@379	667 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);
andrewm@379	668 /**
andrewm@379	669 * Performs a multiply and accumulate operation on the components of a 3D vector with the corresponding components of another.
andrewm@379	670 * This function point could be pointed to one of ne10_vmla_vec3f_c, ne10_vmla_vec3f_neon and ne10_vmla_vec3f_asm.
andrewm@379	671 * @param[out] dst Pointer to the destination array
andrewm@379	672 * @param[in] src1 Pointer to the first source array
andrewm@379	673 * @param[in] src2 Pointer to the second source array
andrewm@379	674 * @param[in] count The number of items in the input arrays
andrewm@379	675 */
andrewm@379	676 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);
andrewm@379	677 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);
andrewm@379	678 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) asm ("ne10_vmla_vec3f_neon");
andrewm@379	679 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);
andrewm@379	680 /**
andrewm@379	681 * Performs a multiply and accumulate operation on the components of a 4D vector with the corresponding components of another.
andrewm@379	682 * This function point could be pointed to one of ne10_vmla_vec4f_c, ne10_vmla_vec4f_neon and ne10_vmla_vec4f_asm.
andrewm@379	683 * @param[out] dst Pointer to the destination array
andrewm@379	684 * @param[in] src1 Pointer to the first source array
andrewm@379	685 * @param[in] src2 Pointer to the second source array
andrewm@379	686 * @param[in] count The number of items in the input arrays
andrewm@379	687 */
andrewm@379	688 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);
andrewm@379	689 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);
andrewm@379	690 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) asm ("ne10_vmla_vec4f_neon");
andrewm@379	691 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);
andrewm@379	692 /** @} */ //end of Vector Multiply-Accumulator group
andrewm@379	693
andrewm@379	694 /**
andrewm@379	695 * @ingroup groupMaths
andrewm@379	696 */
andrewm@379	697
andrewm@379	698 /**
andrewm@379	699 * @defgroup MUL_MAT Matrix Multiply
andrewm@379	700 *
andrewm@379	701 * \par
andrewm@379	702 * These functions implement the matrix multiply operation for float data type.
andrewm@379	703 */
andrewm@379	704
andrewm@379	705 /**
andrewm@379	706 * @addtogroup MUL_MAT
andrewm@379	707 * @{
andrewm@379	708 */
andrewm@379	709
andrewm@379	710 /**
andrewm@379	711 * Matrix multiplication of two 4x4 matrixs.
andrewm@379	712 * This function point could be pointed to one of ne10_mulmat_4x4f_c, ne10_mulmat_4x4f_neon and ne10_mulmat_4x4f_asm.
andrewm@379	713 * @param[out] dst Pointer to the destination array
andrewm@379	714 * @param[in] src1 Pointer to the first source array
andrewm@379	715 * @param[in] src2 Pointer to the second source array
andrewm@379	716 * @param[in] count The number of items in the input arrays
andrewm@379	717 */
andrewm@379	718 extern ne10_result_t (ne10_mulmat_4x4f) (ne10_mat4x4f_t dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	719 extern ne10_result_t ne10_mulmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	720 extern ne10_result_t ne10_mulmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count) asm ("ne10_mulmat_4x4f_neon");
andrewm@379	721 extern ne10_result_t ne10_mulmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	722
andrewm@379	723 /**
andrewm@379	724 * Matrix multiplication of two 3x3 matrixs.
andrewm@379	725 * This function point could be pointed to one of ne10_mulmat_3x3f_c, ne10_mulmat_3x3f_neon and ne10_mulmat_3x3f_asm.
andrewm@379	726 * @param[out] dst Pointer to the destination array
andrewm@379	727 * @param[in] src1 Pointer to the first source array
andrewm@379	728 * @param[in] src2 Pointer to the second source array
andrewm@379	729 * @param[in] count The number of items in the input arrays
andrewm@379	730 */
andrewm@379	731 extern ne10_result_t (ne10_mulmat_3x3f) (ne10_mat3x3f_t dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	732 extern ne10_result_t ne10_mulmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	733 extern ne10_result_t ne10_mulmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count) asm ("ne10_mulmat_3x3f_neon");
andrewm@379	734 extern ne10_result_t ne10_mulmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	735
andrewm@379	736 /**
andrewm@379	737 * Matrix multiplication of two 2x2 matrixs.
andrewm@379	738 * This function point could be pointed to one of ne10_mulmat_2x2f_c, ne10_mulmat_2x2f_neon and ne10_mulmat_2x2f_asm.
andrewm@379	739 * @param[out] dst Pointer to the destination array
andrewm@379	740 * @param[in] src1 Pointer to the first source array
andrewm@379	741 * @param[in] src2 Pointer to the second source array
andrewm@379	742 * @param[in] count The number of items in the input arrays
andrewm@379	743 */
andrewm@379	744 extern ne10_result_t (ne10_mulmat_2x2f) (ne10_mat2x2f_t dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	745 extern ne10_result_t ne10_mulmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	746 extern ne10_result_t ne10_mulmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count) asm ("ne10_mulmat_2x2f_neon");
andrewm@379	747 extern ne10_result_t ne10_mulmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	748 /** @} */ //end of Matrix Multiply group
andrewm@379	749
andrewm@379	750 /**
andrewm@379	751 * @ingroup groupMaths
andrewm@379	752 */
andrewm@379	753
andrewm@379	754 /**
andrewm@379	755 * @defgroup MUL_MAT_VEC Matrix Vector Multiply
andrewm@379	756 *
andrewm@379	757 * \par
andrewm@379	758 * These functions implement the matrix vector multiply operation for float data type.
andrewm@379	759 */
andrewm@379	760
andrewm@379	761 /**
andrewm@379	762 * @addtogroup MUL_MAT_VEC
andrewm@379	763 * @{
andrewm@379	764 */
andrewm@379	765 /**
andrewm@379	766 * Matrix multiplication of 4x4 matrix and 4D vector.
andrewm@379	767 * 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.
andrewm@379	768 * @param[out] dst Pointer to the destination array
andrewm@379	769 * @param[in] cst Pointer to the matrix to multiply the input values with
andrewm@379	770 * @param[in] src Pointer to the source array
andrewm@379	771 * @param[in] count The number of items in the input arrays
andrewm@379	772 */
andrewm@379	773 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);
andrewm@379	774 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);
andrewm@379	775 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) asm ("ne10_mulcmatvec_cm4x4f_v4f_neon");
andrewm@379	776 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);
andrewm@379	777 /**
andrewm@379	778 * Matrix multiplication of 3x3 matrix and 3D vector.
andrewm@379	779 * 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.
andrewm@379	780 * @param[out] dst Pointer to the destination array
andrewm@379	781 * @param[in] cst Pointer to the matrix to multiply the input values with
andrewm@379	782 * @param[in] src Pointer to the source array
andrewm@379	783 * @param[in] count The number of items in the input arrays
andrewm@379	784 */
andrewm@379	785 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);
andrewm@379	786 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);
andrewm@379	787 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) asm ("ne10_mulcmatvec_cm3x3f_v3f_neon");
andrewm@379	788 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);
andrewm@379	789 /**
andrewm@379	790 * Matrix multiplication of 2x2 matrix and 2D vector.
andrewm@379	791 * 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.
andrewm@379	792 * @param[out] dst Pointer to the destination array
andrewm@379	793 * @param[in] cst Pointer to the matrix to multiply the input values with
andrewm@379	794 * @param[in] src Pointer to the source array
andrewm@379	795 * @param[in] count The number of items in the input arrays
andrewm@379	796 */
andrewm@379	797 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);
andrewm@379	798 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);
andrewm@379	799 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) asm ("ne10_mulcmatvec_cm2x2f_v2f_neon");
andrewm@379	800 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);
andrewm@379	801
andrewm@379	802 /** @} */ //end of Matrix Vector Multiply group
andrewm@379	803
andrewm@379	804 /**
andrewm@379	805 * @ingroup groupMaths
andrewm@379	806 */
andrewm@379	807
andrewm@379	808 /**
andrewm@379	809 * @defgroup DIV_VEC Vector Div
andrewm@379	810 *
andrewm@379	811 * \par
andrewm@379	812 * These functions implement the vector division operation for float data type.
andrewm@379	813 */
andrewm@379	814
andrewm@379	815 /**
andrewm@379	816 * @addtogroup DIV_VEC
andrewm@379	817 * @{
andrewm@379	818 */
andrewm@379	819
andrewm@379	820 /**
andrewm@379	821 * Divides the elements of an input array by a constant scalar and stores the results in an output array.
andrewm@379	822 * This function point could be pointed to one of ne10_divc_float_c, ne10_divc_float_neon and ne10_divc_float_asm.
andrewm@379	823 * @param[out] dst Pointer to the destination array
andrewm@379	824 * @param[in] src Pointer to the source array
andrewm@379	825 * @param[in] cst The constant scalar to divide the input values by
andrewm@379	826 * @param[in] count The number of items in the input array
andrewm@379	827 */
andrewm@379	828 extern ne10_result_t (ne10_divc_float) (ne10_float32_t dst, ne10_float32_t * src, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	829 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);
andrewm@379	830 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);
andrewm@379	831 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);
andrewm@379	832 /**
andrewm@379	833 * 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.
andrewm@379	834 * This function point could be pointed to one of ne10_divc_vec2f_c, ne10_divc_vec2f_neon and ne10_divc_vec2f_asm.
andrewm@379	835 * @param[out] dst Pointer to the destination array
andrewm@379	836 * @param[in] src Pointer to the source array
andrewm@379	837 * @param[in] cst Pointer to the 2D vector to divide the input values by
andrewm@379	838 * @param[in] count The number of items in the input array
andrewm@379	839 */
andrewm@379	840 extern ne10_result_t (ne10_divc_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	841 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);
andrewm@379	842 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);
andrewm@379	843 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);
andrewm@379	844 /**
andrewm@379	845 * 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.
andrewm@379	846 * This function point could be pointed to one of ne10_divc_vec3f_c, ne10_divc_vec3f_neon and ne10_divc_vec3f_asm.
andrewm@379	847 * @param[out] dst Pointer to the destination array
andrewm@379	848 * @param[in] src Pointer to the source array
andrewm@379	849 * @param[in] cst Pointer to the 3D vector to divide the input values by
andrewm@379	850 * @param[in] count The number of items in the input array
andrewm@379	851 */
andrewm@379	852 extern ne10_result_t (ne10_divc_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	853 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);
andrewm@379	854 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);
andrewm@379	855 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);
andrewm@379	856 /**
andrewm@379	857 * 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.
andrewm@379	858 * This function point could be pointed to one of ne10_divc_vec4f_c, ne10_divc_vec4f_neon and ne10_divc_vec4f_asm.
andrewm@379	859 * @param[out] dst Pointer to the destination array
andrewm@379	860 * @param[in] src Pointer to the source array
andrewm@379	861 * @param[in] cst Pointer to the 4D vector to divide the input values by
andrewm@379	862 * @param[in] count The number of items in the input array
andrewm@379	863 */
andrewm@379	864 extern ne10_result_t (ne10_divc_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	865 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);
andrewm@379	866 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);
andrewm@379	867 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);
andrewm@379	868 /**
andrewm@379	869 * Divides the elements of src1 by the elements of src2 and stores the results in the dst.
andrewm@379	870 * This function point could be pointed to one of ne10_div_float_c, ne10_div_float_neon and ne10_div_float_asm.
andrewm@379	871 * @param[out] dst Pointer to the destination array
andrewm@379	872 * @param[in] src1 The first array to use as the input array
andrewm@379	873 * @param[in] src2 The second array to use as the input array
andrewm@379	874 * @param[in] count The number of items in the two input arrays
andrewm@379	875 */
andrewm@379	876 extern ne10_result_t (ne10_div_float) (ne10_float32_t dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	877 extern ne10_result_t ne10_div_float_c (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	878 extern ne10_result_t ne10_div_float_neon (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count) asm ("ne10_div_float_neon");
andrewm@379	879 extern ne10_result_t ne10_div_float_asm (ne10_float32_t * dst, ne10_float32_t * src1, ne10_float32_t * src2, ne10_uint32_t count);
andrewm@379	880 /**
andrewm@379	881 * Divides the components of a 2D vector with the corresponding components of another.
andrewm@379	882 * This function point could be pointed to one of ne10_vdiv_vec2f_c, ne10_vdiv_vec2f_neon and ne10_vdiv_vec2f_asm.
andrewm@379	883 * @param[out] dst Pointer to the destination array
andrewm@379	884 * @param[in] src1 Pointer to the nominators' source array
andrewm@379	885 * @param[in] src2 Pointer to the denominators' source array
andrewm@379	886 * @param[in] count The number of items in the input arrays
andrewm@379	887 */
andrewm@379	888 extern ne10_result_t (ne10_vdiv_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	889 extern ne10_result_t ne10_vdiv_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	890 extern ne10_result_t ne10_vdiv_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count) asm ("ne10_vdiv_vec2f_neon");
andrewm@379	891 extern ne10_result_t ne10_vdiv_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	892 /**
andrewm@379	893 * Divides the components of a 3D vector with the corresponding components of another.
andrewm@379	894 * This function point could be pointed to one of ne10_vdiv_vec3f_c, ne10_vdiv_vec3f_neon and ne10_vdiv_vec3f_asm.
andrewm@379	895 * @param[out] dst Pointer to the destination array
andrewm@379	896 * @param[in] src1 Pointer to the nominators' source array
andrewm@379	897 * @param[in] src2 Pointer to the denominators' source array
andrewm@379	898 * @param[in] count The number of items in the input arrays
andrewm@379	899 */
andrewm@379	900 extern ne10_result_t (ne10_vdiv_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	901 extern ne10_result_t ne10_vdiv_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	902 extern ne10_result_t ne10_vdiv_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count) asm ("ne10_vdiv_vec3f_neon");
andrewm@379	903 extern ne10_result_t ne10_vdiv_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	904 /**
andrewm@379	905 * Divides the components of a 4D vector with the corresponding components of another.
andrewm@379	906 * This function point could be pointed to one of ne10_vdiv_vec4f_c, ne10_vdiv_vec4f_neon and ne10_vdiv_vec4f_asm.
andrewm@379	907 * @param[out] dst Pointer to the destination array
andrewm@379	908 * @param[in] src1 Pointer to the nominators' source array
andrewm@379	909 * @param[in] src2 Pointer to the denominators' source array
andrewm@379	910 * @param[in] count The number of items in the input arrays
andrewm@379	911 */
andrewm@379	912 extern ne10_result_t (ne10_vdiv_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	913 extern ne10_result_t ne10_vdiv_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	914 extern ne10_result_t ne10_vdiv_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count) asm ("ne10_vdiv_vec4f_neon");
andrewm@379	915 extern ne10_result_t ne10_vdiv_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	916 /** @} */ //end of Vector Div group
andrewm@379	917
andrewm@379	918 /**
andrewm@379	919 * @ingroup groupMaths
andrewm@379	920 */
andrewm@379	921
andrewm@379	922 /**
andrewm@379	923 * @defgroup DIV_MAT Matrix Div
andrewm@379	924 *
andrewm@379	925 * \par
andrewm@379	926 * These functions implement the matrix division operation for float data type.
andrewm@379	927 */
andrewm@379	928
andrewm@379	929 /**
andrewm@379	930 * @addtogroup DIV_MAT
andrewm@379	931 * @{
andrewm@379	932 */
andrewm@379	933
andrewm@379	934 /**
andrewm@379	935 * Divides the components of a 4x4 matrix with the corresponding components of another.
andrewm@379	936 * This function point could be pointed to one of ne10_divmat_4x4f_c, ne10_divmat_4x4f_neon and ne10_divmat_4x4f_asm.
andrewm@379	937 * @param[out] dst Pointer to the destination array
andrewm@379	938 * @param[in] src1 Pointer to the nominators' source array
andrewm@379	939 * @param[in] src2 Pointer to the denominators' source array
andrewm@379	940 * @param[in] count The number of items in the input arrays
andrewm@379	941 */
andrewm@379	942 extern ne10_result_t (ne10_divmat_4x4f) (ne10_mat4x4f_t dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	943 extern ne10_result_t ne10_divmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	944 extern ne10_result_t ne10_divmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count) asm ("ne10_divmat_4x4f_neon");
andrewm@379	945 extern ne10_result_t ne10_divmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src1, ne10_mat4x4f_t * src2, ne10_uint32_t count);
andrewm@379	946 /**
andrewm@379	947 * Divides the components of a 3x3 matrix with the corresponding components of another.
andrewm@379	948 * This function point could be pointed to one of ne10_divmat_3x3f_c, ne10_divmat_3x3f_neon and ne10_divmat_3x3f_asm.
andrewm@379	949 * @param[out] dst Pointer to the destination array
andrewm@379	950 * @param[in] src1 Pointer to the nominators' source array
andrewm@379	951 * @param[in] src2 Pointer to the denominators' source array
andrewm@379	952 * @param[in] count The number of items in the input arrays
andrewm@379	953 */
andrewm@379	954 extern ne10_result_t (ne10_divmat_3x3f) (ne10_mat3x3f_t dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	955 extern ne10_result_t ne10_divmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	956 extern ne10_result_t ne10_divmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count) asm ("ne10_divmat_3x3f_neon");
andrewm@379	957 extern ne10_result_t ne10_divmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src1, ne10_mat3x3f_t * src2, ne10_uint32_t count);
andrewm@379	958 /**
andrewm@379	959 * Divides the components of a 2x2 matrix with the corresponding components of another.
andrewm@379	960 * This function point could be pointed to one of ne10_divmat_2x2f_c, ne10_divmat_2x2f_neon and ne10_divmat_2x2f_asm.
andrewm@379	961 * @param[out] dst Pointer to the destination array
andrewm@379	962 * @param[in] src1 Pointer to the nominators' source array
andrewm@379	963 * @param[in] src2 Pointer to the denominators' source array
andrewm@379	964 * @param[in] count The number of items in the input arrays
andrewm@379	965 */
andrewm@379	966 extern ne10_result_t (ne10_divmat_2x2f) (ne10_mat2x2f_t dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	967 extern ne10_result_t ne10_divmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	968 extern ne10_result_t ne10_divmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count) asm ("ne10_divmat_2x2f_neon");
andrewm@379	969 extern ne10_result_t ne10_divmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src1, ne10_mat2x2f_t * src2, ne10_uint32_t count);
andrewm@379	970 /** @} */ //end of Matrix Div group
andrewm@379	971
andrewm@379	972 /**
andrewm@379	973 * @ingroup groupMaths
andrewm@379	974 */
andrewm@379	975
andrewm@379	976 /**
andrewm@379	977 * @defgroup SETC_VEC Vector Setc
andrewm@379	978 *
andrewm@379	979 * \par
andrewm@379	980 * These functions implement vector setc operation for float data type.
andrewm@379	981 */
andrewm@379	982
andrewm@379	983 /**
andrewm@379	984 * @addtogroup SETC_VEC
andrewm@379	985 * @{
andrewm@379	986 */
andrewm@379	987
andrewm@379	988 /**
andrewm@379	989 * Sets the elements of an input array to a constant scalar and stores the results in an output array.
andrewm@379	990 * This function point could be pointed to one of ne10_setc_float_c, ne10_setc_float_neon and ne10_setc_float_asm.
andrewm@379	991 * @param[out] dst Pointer to the destination array
andrewm@379	992 * @param[in] cst The constant scalar to set the input values to
andrewm@379	993 * @param[in] count The number of items in the input array
andrewm@379	994 */
andrewm@379	995 extern ne10_result_t (ne10_setc_float) (ne10_float32_t dst, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	996 extern ne10_result_t ne10_setc_float_c (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	997 extern ne10_result_t ne10_setc_float_neon (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	998 extern ne10_result_t ne10_setc_float_asm (ne10_float32_t * dst, const ne10_float32_t cst, ne10_uint32_t count);
andrewm@379	999 /**
andrewm@379	1000 * 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.
andrewm@379	1001 * This function point could be pointed to one of ne10_setc_vec2f_c, ne10_setc_vec2f_neon and ne10_setc_vec2f_asm.
andrewm@379	1002 * @param[out] dst Pointer to the destination array
andrewm@379	1003 * @param[in] cst Pointer to the 2D vector to set the input values to
andrewm@379	1004 * @param[in] count The number of items in the input array
andrewm@379	1005 */
andrewm@379	1006 extern ne10_result_t (ne10_setc_vec2f) (ne10_vec2f_t dst, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	1007 extern ne10_result_t ne10_setc_vec2f_c (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	1008 extern ne10_result_t ne10_setc_vec2f_neon (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	1009 extern ne10_result_t ne10_setc_vec2f_asm (ne10_vec2f_t * dst, const ne10_vec2f_t * cst, ne10_uint32_t count);
andrewm@379	1010 /**
andrewm@379	1011 * 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.
andrewm@379	1012 * This function point could be pointed to one of ne10_setc_vec3f_c, ne10_setc_vec3f_neon and ne10_setc_vec3f_asm.
andrewm@379	1013 * @param[out] dst Pointer to the destination array
andrewm@379	1014 * @param[in] cst Pointer to the 3D vector to set the input values to
andrewm@379	1015 * @param[in] count The number of items in the input array
andrewm@379	1016 */
andrewm@379	1017 extern ne10_result_t (ne10_setc_vec3f) (ne10_vec3f_t dst, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	1018 extern ne10_result_t ne10_setc_vec3f_c (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	1019 extern ne10_result_t ne10_setc_vec3f_neon (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	1020 extern ne10_result_t ne10_setc_vec3f_asm (ne10_vec3f_t * dst, const ne10_vec3f_t * cst, ne10_uint32_t count);
andrewm@379	1021 /**
andrewm@379	1022 * 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.
andrewm@379	1023 * This function point could be pointed to one of ne10_setc_vec4f_c, ne10_setc_vec4f_neon and ne10_setc_vec4f_asm.
andrewm@379	1024 * @param[out] dst Pointer to the destination array
andrewm@379	1025 * @param[in] cst Pointer to the 4D vector to set the input values to
andrewm@379	1026 * @param[in] count The number of items in the input array
andrewm@379	1027 */
andrewm@379	1028 extern ne10_result_t (ne10_setc_vec4f) (ne10_vec4f_t dst, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	1029 extern ne10_result_t ne10_setc_vec4f_c (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	1030 extern ne10_result_t ne10_setc_vec4f_neon (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	1031 extern ne10_result_t ne10_setc_vec4f_asm (ne10_vec4f_t * dst, const ne10_vec4f_t * cst, ne10_uint32_t count);
andrewm@379	1032 /** @} */ //end of Vector Setc group
andrewm@379	1033
andrewm@379	1034 /**
andrewm@379	1035 * @ingroup groupMaths
andrewm@379	1036 */
andrewm@379	1037
andrewm@379	1038 /**
andrewm@379	1039 * @defgroup LEN_VEC Vector Len
andrewm@379	1040 *
andrewm@379	1041 * \par
andrewm@379	1042 * These functions implement vector len operation for float data type.
andrewm@379	1043 */
andrewm@379	1044
andrewm@379	1045 /**
andrewm@379	1046 * @addtogroup LEN_VEC
andrewm@379	1047 * @{
andrewm@379	1048 */
andrewm@379	1049 /**
andrewm@379	1050 * Returns length of 2D vectors in corresponding elements of the output array.
andrewm@379	1051 * This function point could be pointed to one of ne10_len_vec2f_c, ne10_len_vec2f_neon and ne10_len_vec2f_asm.
andrewm@379	1052 * @param[out] dst Pointer to the destination array
andrewm@379	1053 * @param[in] src Pointer to the source array
andrewm@379	1054 * @param[in] count The number of items in the input array
andrewm@379	1055 */
andrewm@379	1056 extern ne10_result_t (ne10_len_vec2f) (ne10_float32_t dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1057 extern ne10_result_t ne10_len_vec2f_c (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1058 extern ne10_result_t ne10_len_vec2f_neon (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count) asm ("ne10_len_vec2f_neon");
andrewm@379	1059 extern ne10_result_t ne10_len_vec2f_asm (ne10_float32_t * dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1060 /**
andrewm@379	1061 * Returns length of 3D vectors in corresponding elements of the output array.
andrewm@379	1062 * This function point could be pointed to one of ne10_len_vec3f_c, ne10_len_vec3f_neon and ne10_len_vec3f_asm.
andrewm@379	1063 * @param[out] dst Pointer to the destination array
andrewm@379	1064 * @param[in] src Pointer to the source array
andrewm@379	1065 * @param[in] count The number of items in the input array
andrewm@379	1066 */
andrewm@379	1067 extern ne10_result_t (ne10_len_vec3f) (ne10_float32_t dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1068 extern ne10_result_t ne10_len_vec3f_c (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1069 extern ne10_result_t ne10_len_vec3f_neon (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count) asm ("ne10_len_vec3f_neon");
andrewm@379	1070 extern ne10_result_t ne10_len_vec3f_asm (ne10_float32_t * dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1071 /**
andrewm@379	1072 * Returns length of 4D vectors in corresponding elements of the output array.
andrewm@379	1073 * This function point could be pointed to one of ne10_len_vec4f_c, ne10_len_vec4f_neon and ne10_len_vec4f_asm.
andrewm@379	1074 * @param[out] dst Pointer to the destination array
andrewm@379	1075 * @param[in] src Pointer to the source array
andrewm@379	1076 * @param[in] count The number of items in the input array
andrewm@379	1077 */
andrewm@379	1078 extern ne10_result_t (ne10_len_vec4f) (ne10_float32_t dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1079 extern ne10_result_t ne10_len_vec4f_c (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1080 extern ne10_result_t ne10_len_vec4f_neon (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count) asm ("ne10_len_vec4f_neon");
andrewm@379	1081 extern ne10_result_t ne10_len_vec4f_asm (ne10_float32_t * dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1082 /** @} */ //end of Vector Len group
andrewm@379	1083
andrewm@379	1084
andrewm@379	1085 /**
andrewm@379	1086 * @ingroup groupMaths
andrewm@379	1087 */
andrewm@379	1088
andrewm@379	1089 /**
andrewm@379	1090 * @defgroup NORM_VEC Vector Normalize
andrewm@379	1091 *
andrewm@379	1092 * \par
andrewm@379	1093 * These functions implement vector normalize operation for float data type.
andrewm@379	1094 */
andrewm@379	1095
andrewm@379	1096 /**
andrewm@379	1097 * @addtogroup NORM_VEC
andrewm@379	1098 * @{
andrewm@379	1099 */
andrewm@379	1100 /**
andrewm@379	1101 * Normalizes 2D vectors of the input array and stores them in the corresponding elements of the output array.
andrewm@379	1102 * This function point could be pointed to one of ne10_normalize_vec2f_c, ne10_normalize_vec2f_neon and ne10_normalize_vec2f_asm.
andrewm@379	1103 * @param[out] dst Pointer to the destination array
andrewm@379	1104 * @param[in] src Pointer to the source array
andrewm@379	1105 * @param[in] count The number of items in the input array
andrewm@379	1106 */
andrewm@379	1107 extern ne10_result_t (ne10_normalize_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1108 extern ne10_result_t ne10_normalize_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1109 extern ne10_result_t ne10_normalize_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count) asm ("ne10_normalize_vec2f_neon");
andrewm@379	1110 extern ne10_result_t ne10_normalize_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1111 /**
andrewm@379	1112 * Normalizes 3D vectors of the input array and stores them in the corresponding elements of the output array.
andrewm@379	1113 * This function point could be pointed to one of ne10_normalize_vec3f_c, ne10_normalize_vec3f_neon and ne10_normalize_vec3f_asm.
andrewm@379	1114 * @param[out] dst Pointer to the destination array
andrewm@379	1115 * @param[in] src Pointer to the source array
andrewm@379	1116 * @param[in] count The number of items in the input array
andrewm@379	1117 */
andrewm@379	1118 extern ne10_result_t (ne10_normalize_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1119 extern ne10_result_t ne10_normalize_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1120 extern ne10_result_t ne10_normalize_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count) asm ("ne10_normalize_vec3f_neon");
andrewm@379	1121 extern ne10_result_t ne10_normalize_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1122 /**
andrewm@379	1123 * Normalizes 4D vectors of the input array and stores them in the corresponding elements of the output array.
andrewm@379	1124 * This function point could be pointed to one of ne10_normalize_vec4f_c, ne10_normalize_vec4f_neon and ne10_normalize_vec4f_asm.
andrewm@379	1125 * @param[out] dst Pointer to the destination array
andrewm@379	1126 * @param[in] src Pointer to the source array
andrewm@379	1127 * @param[in] count The number of items in the input array
andrewm@379	1128 */
andrewm@379	1129 extern ne10_result_t (ne10_normalize_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1130 extern ne10_result_t ne10_normalize_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1131 extern ne10_result_t ne10_normalize_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count) asm ("ne10_normalize_vec4f_neon");
andrewm@379	1132 extern ne10_result_t ne10_normalize_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1133 /** @} */ //end of Vector Normalize group
andrewm@379	1134
andrewm@379	1135
andrewm@379	1136 /**
andrewm@379	1137 * @ingroup groupMaths
andrewm@379	1138 */
andrewm@379	1139
andrewm@379	1140 /**
andrewm@379	1141 * @defgroup ABS_VEC Vector Abs
andrewm@379	1142 *
andrewm@379	1143 * \par
andrewm@379	1144 * These functions implement vector abs operation for float data type.
andrewm@379	1145 */
andrewm@379	1146
andrewm@379	1147 /**
andrewm@379	1148 * @addtogroup ABS_VEC
andrewm@379	1149 * @{
andrewm@379	1150 */
andrewm@379	1151
andrewm@379	1152 /**
andrewm@379	1153 * Calculates the absolute value of each element in the source array and stores the result in the corresponding entry of the destination array.
andrewm@379	1154 * This function point could be pointed to one of ne10_abs_float_c, ne10_abs_float_neon and ne10_abs_float_asm.
andrewm@379	1155 * @param[out] dst Pointer to the destination array
andrewm@379	1156 * @param[in] src Pointer to the source array
andrewm@379	1157 * @param[in] count The number of items in the input array
andrewm@379	1158 */
andrewm@379	1159 extern ne10_result_t (ne10_abs_float) (ne10_float32_t dst, ne10_float32_t * src, ne10_uint32_t count);
andrewm@379	1160 extern ne10_result_t ne10_abs_float_c (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count);
andrewm@379	1161 extern ne10_result_t ne10_abs_float_neon (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count) asm ("ne10_abs_float_neon");
andrewm@379	1162 extern ne10_result_t ne10_abs_float_asm (ne10_float32_t * dst, ne10_float32_t * src, ne10_uint32_t count);
andrewm@379	1163 /**
andrewm@379	1164 * Generates a 2D vector from the absolute values of each of the components of an input vector.
andrewm@379	1165 * This function point could be pointed to one of ne10_abs_vec2f_c, ne10_abs_vec2f_neon and ne10_abs_vec2f_asm.
andrewm@379	1166 * @param[out] dst Pointer to the destination array
andrewm@379	1167 * @param[in] src Pointer to the source array
andrewm@379	1168 * @param[in] count The number of items in the input array
andrewm@379	1169 */
andrewm@379	1170 extern ne10_result_t (ne10_abs_vec2f) (ne10_vec2f_t dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1171 extern ne10_result_t ne10_abs_vec2f_c (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1172 extern ne10_result_t ne10_abs_vec2f_neon (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count) asm ("ne10_abs_vec2f_neon");
andrewm@379	1173 extern ne10_result_t ne10_abs_vec2f_asm (ne10_vec2f_t * dst, ne10_vec2f_t * src, ne10_uint32_t count);
andrewm@379	1174 /**
andrewm@379	1175 * Generates a 3D vector from the absolute values of each of the components of an input vector.
andrewm@379	1176 * This function point could be pointed to one of ne10_abs_vec3f_c, ne10_abs_vec3f_neon and ne10_abs_vec3f_asm.
andrewm@379	1177 * @param[out] dst Pointer to the destination array
andrewm@379	1178 * @param[in] src Pointer to the source array
andrewm@379	1179 * @param[in] count The number of items in the input array
andrewm@379	1180 */
andrewm@379	1181 extern ne10_result_t (ne10_abs_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1182 extern ne10_result_t ne10_abs_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1183 extern ne10_result_t ne10_abs_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count) asm ("ne10_abs_vec3f_neon");
andrewm@379	1184 extern ne10_result_t ne10_abs_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src, ne10_uint32_t count);
andrewm@379	1185 /**
andrewm@379	1186 * Generates a 4D vector from the absolute values of each of the components of an input vector.
andrewm@379	1187 * This function point could be pointed to one of ne10_abs_vec4f_c, ne10_abs_vec4f_neon and ne10_abs_vec4f_asm.
andrewm@379	1188 * @param[out] dst Pointer to the destination array
andrewm@379	1189 * @param[in] src Pointer to the source array
andrewm@379	1190 * @param[in] count The number of items in the input array
andrewm@379	1191 */
andrewm@379	1192 extern ne10_result_t (ne10_abs_vec4f) (ne10_vec4f_t dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1193 extern ne10_result_t ne10_abs_vec4f_c (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1194 extern ne10_result_t ne10_abs_vec4f_neon (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count) asm ("ne10_abs_vec4f_neon");
andrewm@379	1195 extern ne10_result_t ne10_abs_vec4f_asm (ne10_vec4f_t * dst, ne10_vec4f_t * src, ne10_uint32_t count);
andrewm@379	1196 /** @} */ //end of Vector Abs group
andrewm@379	1197
andrewm@379	1198 /**
andrewm@379	1199 * @ingroup groupMaths
andrewm@379	1200 */
andrewm@379	1201
andrewm@379	1202 /**
andrewm@379	1203 * @defgroup DOT_VEC Vector Dot
andrewm@379	1204 *
andrewm@379	1205 * \par
andrewm@379	1206 * These functions implement vector dot operation for float data type.
andrewm@379	1207 */
andrewm@379	1208
andrewm@379	1209 /**
andrewm@379	1210 * @addtogroup DOT_VEC
andrewm@379	1211 * @{
andrewm@379	1212 */
andrewm@379	1213 /**
andrewm@379	1214 * Dot product of two 2D vectors.
andrewm@379	1215 * This function point could be pointed to one of ne10_dot_vec2f_c, ne10_dot_vec2f_neon and ne10_dot_vec2f_asm.
andrewm@379	1216 * @param[out] dst Pointer to the destination array
andrewm@379	1217 * @param[in] src1 Pointer to the first source array
andrewm@379	1218 * @param[in] src2 Pointer to the second source array
andrewm@379	1219 * @param[in] count The number of items in the input arrays
andrewm@379	1220 */
andrewm@379	1221 extern ne10_result_t (ne10_dot_vec2f) (ne10_float32_t dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	1222 extern ne10_result_t ne10_dot_vec2f_c (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	1223 extern ne10_result_t ne10_dot_vec2f_neon (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count) asm ("ne10_dot_vec2f_neon");
andrewm@379	1224 extern ne10_result_t ne10_dot_vec2f_asm (ne10_float32_t * dst, ne10_vec2f_t * src1, ne10_vec2f_t * src2, ne10_uint32_t count);
andrewm@379	1225 /**
andrewm@379	1226 * Dot product of two 3D vectors.
andrewm@379	1227 * This function point could be pointed to one of ne10_dot_vec3f_c, ne10_dot_vec3f_neon and ne10_dot_vec3f_asm.
andrewm@379	1228 * @param[out] dst Pointer to the destination array
andrewm@379	1229 * @param[in] src1 Pointer to the first source array
andrewm@379	1230 * @param[in] src2 Pointer to the second source array
andrewm@379	1231 * @param[in] count The number of items in the input arrays
andrewm@379	1232 */
andrewm@379	1233 extern ne10_result_t (ne10_dot_vec3f) (ne10_float32_t dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	1234 extern ne10_result_t ne10_dot_vec3f_c (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	1235 extern ne10_result_t ne10_dot_vec3f_neon (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count) asm ("ne10_dot_vec3f_neon");
andrewm@379	1236 extern ne10_result_t ne10_dot_vec3f_asm (ne10_float32_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	1237 /**
andrewm@379	1238 * Dot product of two 4D vectors.
andrewm@379	1239 * This function point could be pointed to one of ne10_dot_vec4f_c, ne10_dot_vec4f_neon and ne10_dot_vec4f_asm.
andrewm@379	1240 * @param[out] dst Pointer to the destination array
andrewm@379	1241 * @param[in] src1 Pointer to the first source array
andrewm@379	1242 * @param[in] src2 Pointer to the second source array
andrewm@379	1243 * @param[in] count The number of items in the input arrays
andrewm@379	1244 */
andrewm@379	1245 extern ne10_result_t (ne10_dot_vec4f) (ne10_float32_t dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	1246 extern ne10_result_t ne10_dot_vec4f_c (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	1247 extern ne10_result_t ne10_dot_vec4f_neon (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count) asm ("ne10_dot_vec4f_neon");
andrewm@379	1248 extern ne10_result_t ne10_dot_vec4f_asm (ne10_float32_t * dst, ne10_vec4f_t * src1, ne10_vec4f_t * src2, ne10_uint32_t count);
andrewm@379	1249 /** @} */ //end of Vector Dot group
andrewm@379	1250
andrewm@379	1251
andrewm@379	1252 /**
andrewm@379	1253 * @ingroup groupMaths
andrewm@379	1254 */
andrewm@379	1255
andrewm@379	1256 /**
andrewm@379	1257 * @defgroup CROSS_VEC Vector Cross
andrewm@379	1258 *
andrewm@379	1259 * \par
andrewm@379	1260 * These functions implement vector cross operation for float data type.
andrewm@379	1261 */
andrewm@379	1262
andrewm@379	1263 /**
andrewm@379	1264 * @addtogroup CROSS_VEC
andrewm@379	1265 * @{
andrewm@379	1266 */
andrewm@379	1267
andrewm@379	1268 /**
andrewm@379	1269 * Performs a cross product operation on the two input vectors.
andrewm@379	1270 * This function point could be pointed to one of ne10_cross_vec3f_c, ne10_cross_vec3f_neon and ne10_cross_vec3f_asm.
andrewm@379	1271 * @param[out] dst Pointer to the destination array
andrewm@379	1272 * @param[in] src1 Pointer to the first source array
andrewm@379	1273 * @param[in] src2 Pointer to the second source array
andrewm@379	1274 * @param[in] count The number of items in the input arrays
andrewm@379	1275 */
andrewm@379	1276 extern ne10_result_t (ne10_cross_vec3f) (ne10_vec3f_t dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	1277 extern ne10_result_t ne10_cross_vec3f_c (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	1278 extern ne10_result_t ne10_cross_vec3f_neon (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count) asm ("ne10_cross_vec3f_neon");
andrewm@379	1279 extern ne10_result_t ne10_cross_vec3f_asm (ne10_vec3f_t * dst, ne10_vec3f_t * src1, ne10_vec3f_t * src2, ne10_uint32_t count);
andrewm@379	1280 /** @} */ //end of Vector Cross group
andrewm@379	1281
andrewm@379	1282 /**
andrewm@379	1283 * @ingroup groupMaths
andrewm@379	1284 */
andrewm@379	1285
andrewm@379	1286 /**
andrewm@379	1287 * @defgroup DET_MAT Matrix Determinant
andrewm@379	1288 *
andrewm@379	1289 * \par
andrewm@379	1290 * These functions implement matrix determinant operation for float data type.
andrewm@379	1291 */
andrewm@379	1292
andrewm@379	1293 /**
andrewm@379	1294 * @addtogroup DET_MAT
andrewm@379	1295 * @{
andrewm@379	1296 */
andrewm@379	1297
andrewm@379	1298 /**
andrewm@379	1299 * Calculate the determinant of a 4x4 matrix.
andrewm@379	1300 * This function point could be pointed to one of ne10_detmat_4x4f_c, ne10_detmat_4x4f_neon and ne10_detmat_4x4f_asm.
andrewm@379	1301 * @param[out] dst Pointer to the destination array
andrewm@379	1302 * @param[in] src Pointer to the source array
andrewm@379	1303 * @param[in] count The number of items in the input array
andrewm@379	1304 */
andrewm@379	1305 extern ne10_result_t (ne10_detmat_4x4f) (ne10_float32_t dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1306 extern ne10_result_t ne10_detmat_4x4f_c (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1307 extern ne10_result_t ne10_detmat_4x4f_neon (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count) asm ("ne10_detmat_4x4f_neon");
andrewm@379	1308 extern ne10_result_t ne10_detmat_4x4f_asm (ne10_float32_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1309 /**
andrewm@379	1310 * Calculate the determinant of a 3x3 matrix.
andrewm@379	1311 * This function point could be pointed to one of ne10_detmat_3x3f_c, ne10_detmat_3x3f_neon and ne10_detmat_3x3f_asm.
andrewm@379	1312 * @param[out] dst Pointer to the destination array
andrewm@379	1313 * @param[in] src Pointer to the source array
andrewm@379	1314 * @param[in] count The number of items in the input array
andrewm@379	1315 */
andrewm@379	1316 extern ne10_result_t (ne10_detmat_3x3f) (ne10_float32_t dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1317 extern ne10_result_t ne10_detmat_3x3f_c (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1318 extern ne10_result_t ne10_detmat_3x3f_neon (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count) asm ("ne10_detmat_3x3f_neon");
andrewm@379	1319 extern ne10_result_t ne10_detmat_3x3f_asm (ne10_float32_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1320 /**
andrewm@379	1321 * Calculate the determinant of a 2x2 matrix.
andrewm@379	1322 * This function point could be pointed to one of ne10_detmat_2x2f_c, ne10_detmat_2x2f_neon and ne10_detmat_2x2f_asm.
andrewm@379	1323 * @param[out] dst Pointer to the destination array
andrewm@379	1324 * @param[in] src Pointer to the source array
andrewm@379	1325 * @param[in] count The number of items in the input array
andrewm@379	1326 */
andrewm@379	1327 extern ne10_result_t (ne10_detmat_2x2f) (ne10_float32_t dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1328 extern ne10_result_t ne10_detmat_2x2f_c (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1329 extern ne10_result_t ne10_detmat_2x2f_neon (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count) asm ("ne10_detmat_2x2f_neon");
andrewm@379	1330 extern ne10_result_t ne10_detmat_2x2f_asm (ne10_float32_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1331 /** @} */ //end of Matrix Determinant group
andrewm@379	1332
andrewm@379	1333 /**
andrewm@379	1334 * @ingroup groupMaths
andrewm@379	1335 */
andrewm@379	1336
andrewm@379	1337 /**
andrewm@379	1338 * @defgroup INV_MAT Matrix Invertible
andrewm@379	1339 *
andrewm@379	1340 * \par
andrewm@379	1341 * These functions implement matrix invertible operation for float data type.
andrewm@379	1342 */
andrewm@379	1343
andrewm@379	1344 /**
andrewm@379	1345 * @addtogroup INV_MAT
andrewm@379	1346 * @{
andrewm@379	1347 */
andrewm@379	1348 /**
andrewm@379	1349 * Calculate the invertible matrix of a 4x4 matrix.
andrewm@379	1350 * This function point could be pointed to one of ne10_invmat_4x4f_c, ne10_invmat_4x4f_neon and ne10_invmat_4x4f_asm.
andrewm@379	1351 * @param[out] dst Pointer to the destination array
andrewm@379	1352 * @param[in] src Pointer to the source array
andrewm@379	1353 * @param[in] count The number of items in the input array
andrewm@379	1354 */
andrewm@379	1355 extern ne10_result_t (ne10_invmat_4x4f) (ne10_mat4x4f_t dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1356 extern ne10_result_t ne10_invmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1357 extern ne10_result_t ne10_invmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count) asm ("ne10_invmat_4x4f_neon");
andrewm@379	1358 extern ne10_result_t ne10_invmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1359 /**
andrewm@379	1360 * Calculate the invertible matrix of a 3x3 matrix.
andrewm@379	1361 * This function point could be pointed to one of ne10_invmat_3x3f_c, ne10_invmat_3x3f_neon and ne10_invmat_3x3f_asm.
andrewm@379	1362 * @param[out] dst Pointer to the destination array
andrewm@379	1363 * @param[in] src Pointer to the source array
andrewm@379	1364 * @param[in] count The number of items in the input array
andrewm@379	1365 */
andrewm@379	1366 extern ne10_result_t (ne10_invmat_3x3f) (ne10_mat3x3f_t dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1367 extern ne10_result_t ne10_invmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1368 extern ne10_result_t ne10_invmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count) asm ("ne10_invmat_3x3f_neon");
andrewm@379	1369 extern ne10_result_t ne10_invmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1370 /**
andrewm@379	1371 * Calculate the invertible matrix of a 2x2 matrix.
andrewm@379	1372 * This function point could be pointed to one of ne10_invmat_2x2f_c, ne10_invmat_2x2f_neon and ne10_invmat_2x2f_asm.
andrewm@379	1373 * @param[out] dst Pointer to the destination array
andrewm@379	1374 * @param[in] src Pointer to the source array
andrewm@379	1375 * @param[in] count The number of items in the input array
andrewm@379	1376 */
andrewm@379	1377 extern ne10_result_t (ne10_invmat_2x2f) (ne10_mat2x2f_t dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1378 extern ne10_result_t ne10_invmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1379 extern ne10_result_t ne10_invmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count) asm ("ne10_invmat_2x2f_neon");
andrewm@379	1380 extern ne10_result_t ne10_invmat_2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1381 /** @} */ //end of Matrix Invertible group
andrewm@379	1382
andrewm@379	1383 /**
andrewm@379	1384 * @ingroup groupMaths
andrewm@379	1385 */
andrewm@379	1386
andrewm@379	1387 /**
andrewm@379	1388 * @defgroup TRANS_MAT Matrix Transpose
andrewm@379	1389 *
andrewm@379	1390 * \par
andrewm@379	1391 * These functions implement matrix transpose operation for float data type.
andrewm@379	1392 */
andrewm@379	1393
andrewm@379	1394 /**
andrewm@379	1395 * @addtogroup TRANS_MAT
andrewm@379	1396 * @{
andrewm@379	1397 */
andrewm@379	1398 /**
andrewm@379	1399 * Calculate the transpose matrix of a 4x4 matrix.
andrewm@379	1400 * This function point could be pointed to one of ne10_transmat_4x4f_c, ne10_transmat_4x4f_neon and ne10_transmat_4x4f_asm.
andrewm@379	1401 * @param[out] dst Pointer to the destination array
andrewm@379	1402 * @param[in] src Pointer to the source array
andrewm@379	1403 * @param[in] count The number of items in the input array
andrewm@379	1404 */
andrewm@379	1405 extern ne10_result_t (ne10_transmat_4x4f) (ne10_mat4x4f_t dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1406 extern ne10_result_t ne10_transmat_4x4f_c (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1407 extern ne10_result_t ne10_transmat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count) asm ("ne10_transmat_4x4f_neon");
andrewm@379	1408 extern ne10_result_t ne10_transmat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_mat4x4f_t * src, ne10_uint32_t count);
andrewm@379	1409 /**
andrewm@379	1410 * Calculate the transpose matrix of a 4x4 matrix.
andrewm@379	1411 * This function point could be pointed to one of ne10_transmat_4x4f_c, ne10_transmat_4x4f_neon and ne10_transmat_4x4f_asm.
andrewm@379	1412 * @param[out] dst Pointer to the destination array
andrewm@379	1413 * @param[in] src Pointer to the source array
andrewm@379	1414 * @param[in] count The number of items in the input array
andrewm@379	1415 */
andrewm@379	1416 extern ne10_result_t (ne10_transmat_3x3f) (ne10_mat3x3f_t dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1417 extern ne10_result_t ne10_transmat_3x3f_c (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1418 extern ne10_result_t ne10_transmat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count) asm ("ne10_transmat_3x3f_neon");
andrewm@379	1419 extern ne10_result_t ne10_transmat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_mat3x3f_t * src, ne10_uint32_t count);
andrewm@379	1420 /**
andrewm@379	1421 * Calculate the transpose matrix of a 3x3 matrix.
andrewm@379	1422 * This function point could be pointed to one of ne10_transmat_3x3f_c, ne10_transmat_3x3f_neon and ne10_transmat_3x3f_asm.
andrewm@379	1423 * @param[out] dst Pointer to the destination array
andrewm@379	1424 * @param[in] src Pointer to the source array
andrewm@379	1425 * @param[in] count The number of items in the input array
andrewm@379	1426 */
andrewm@379	1427 extern ne10_result_t (ne10_transmat_2x2f) (ne10_mat2x2f_t dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1428 extern ne10_result_t ne10_transmat_2x2f_c (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1429 extern ne10_result_t ne10_transmat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count) asm ("ne10_transmat_2x2f_neon");
andrewm@379	1430 extern ne10_result_t ne10_trans_mat2x2f_asm (ne10_mat2x2f_t * dst, ne10_mat2x2f_t * src, ne10_uint32_t count);
andrewm@379	1431 /** @} */ //end of Matrix Transpose group
andrewm@379	1432
andrewm@379	1433 /**
andrewm@379	1434 * @ingroup groupMaths
andrewm@379	1435 */
andrewm@379	1436
andrewm@379	1437 /**
andrewm@379	1438 * @defgroup IDENTITY_MAT Matrix Identity
andrewm@379	1439 *
andrewm@379	1440 * \par
andrewm@379	1441 * These functions implement matrix identity operation for float data type.
andrewm@379	1442 */
andrewm@379	1443
andrewm@379	1444 /**
andrewm@379	1445 * @addtogroup IDENTITY_MAT
andrewm@379	1446 * @{
andrewm@379	1447 */
andrewm@379	1448 /**
andrewm@379	1449 * Set the identity matrix of a 2x2 matrix.
andrewm@379	1450 * This function point could be pointed to one of ne10_identitymat_2x2f_c, ne10_identitymat_2x2f_neon and ne10_identitymat_2x2f_asm.
andrewm@379	1451 * @param[out] dst Pointer to the destination array
andrewm@379	1452 * @param[in] count The number of items in the input array
andrewm@379	1453 */
andrewm@379	1454 extern ne10_result_t (ne10_identitymat_4x4f) (ne10_mat4x4f_t dst, ne10_uint32_t count);
andrewm@379	1455 extern ne10_result_t ne10_identitymat_4x4f_c (ne10_mat4x4f_t * dst, ne10_uint32_t count);
andrewm@379	1456 extern ne10_result_t ne10_identitymat_4x4f_neon (ne10_mat4x4f_t * dst, ne10_uint32_t count) asm ("ne10_identitymat_4x4f_neon");
andrewm@379	1457 extern ne10_result_t ne10_identitymat_4x4f_asm (ne10_mat4x4f_t * dst, ne10_uint32_t count);
andrewm@379	1458 /**
andrewm@379	1459 * Set the identity matrix of a 3x3 matrix.
andrewm@379	1460 * This function point could be pointed to one of ne10_identitymat_3x3f_c, ne10_identitymat_3x3f_neon and ne10_identitymat_3x3f_asm.
andrewm@379	1461 * @param[out] dst Pointer to the destination array
andrewm@379	1462 * @param[in] count The number of items in the input array
andrewm@379	1463 */
andrewm@379	1464 extern ne10_result_t (ne10_identitymat_3x3f) (ne10_mat3x3f_t dst, ne10_uint32_t count);
andrewm@379	1465 extern ne10_result_t ne10_identitymat_3x3f_c (ne10_mat3x3f_t * dst, ne10_uint32_t count);
andrewm@379	1466 extern ne10_result_t ne10_identitymat_3x3f_neon (ne10_mat3x3f_t * dst, ne10_uint32_t count) asm ("ne10_identitymat_3x3f_neon");
andrewm@379	1467 extern ne10_result_t ne10_identitymat_3x3f_asm (ne10_mat3x3f_t * dst, ne10_uint32_t count);
andrewm@379	1468 /**
andrewm@379	1469 * Set the identity matrix of a 2x2 matrix.
andrewm@379	1470 * This function point could be pointed to one of ne10_identitymat_2x2f_c, ne10_identitymat_2x2f_neon and ne10_identitymat_2x2f_asm.
andrewm@379	1471 * @param[out] dst Pointer to the destination array
andrewm@379	1472 * @param[in] count The number of items in the input array
andrewm@379	1473 */
andrewm@379	1474 extern ne10_result_t (ne10_identitymat_2x2f) (ne10_mat2x2f_t dst, ne10_uint32_t count);
andrewm@379	1475 extern ne10_result_t ne10_identitymat_2x2f_c (ne10_mat2x2f_t * dst, ne10_uint32_t count);
andrewm@379	1476 extern ne10_result_t ne10_identitymat_2x2f_neon (ne10_mat2x2f_t * dst, ne10_uint32_t count) asm ("ne10_identitymat_2x2f_neon");
andrewm@379	1477 extern ne10_result_t ne10_identity_mat2x2f_asm (ne10_mat2x2f_t * dst, ne10_uint32_t count);
andrewm@379	1478 /** @} */ //end of Matrix Identity group
andrewm@379	1479
andrewm@379	1480 #ifdef __cplusplus
andrewm@379	1481 }
andrewm@379	1482 #endif
andrewm@379	1483
andrewm@379	1484 #endif

Mercurial > hg > beaglert

annotate include/ne10/NE10_math.h @ 513:485913c58a61 prerelease