Mercurial > hg > beaglert

annotate include/ne10/NE10_math.h @ 500:b935f890e512 prerelease

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Updated Doxy to 1.8.11 Amended example titles in render.cpp and file locations in Doxy file.
author Robert Jack <robert.h.jack@gmail.com>
date Wed, 22 Jun 2016 00:27:13 +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