GitHub-Mirror/bl_mcu_sdk
2
0
Fork 0
mirror of https://github.com/Fishwaldo/bl_mcu_sdk.git synced 2025-07-22 20:59:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[feat][nmsis] add nmsis component and nn,dsp demo

Browse source
This commit is contained in:
jzlv 2021-09-26 13:38:51 +08:00
parent b2aada479b
commit 5d1126d0f0
989 changed files with 286224 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

6
examples/dsp/MatrixFunctions_q31Part/CMakeLists.txt Normal file
View file

@ -0,0 +1,6 @@
set(TARGET_REQUIRED_PRIVATE_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/..)
list(APPEND TARGET_REQUIRED_SRCS mat_add.c mat_cmplx_mult.c mat_inverse.c)
list(APPEND TARGET_REQUIRED_SRCS mat_mult.c mat_scale.c mat_sub.c mat_trans.c)
set(TARGET_REQUIRED_LIBS nmsis)
set(mains main.c)
generate_bin()

26
examples/dsp/MatrixFunctions_q31Part/array.h Normal file
View file

@ -0,0 +1,26 @@
// Array for MatrixFunctions q31Part
#define ROWS 64
#define COLUMNS 64
q31_t q31_a_array[ROWS * COLUMNS] = {
497, 1806, 789, 1963, 2068, 2245, 1352, 252, 687, 2741, 458, 2478,
1616, 2989, 235, 1329, 320, 2886, 14, 2325, 2452, 2607, 254, 1200,
780, 2401, 1295, 2732, 546, 792, 437, 409, 2608, 1740, 1650, 435,
2560, 1867, 1053, 1540, 1206, 228, 720, 370, 552, 720, 1252, 149,
2709, 2835, 1473, 1468, 1014, 2701, 1108, 334, 2341, 1170, 726, 1212,
290, 396, 2827, 2869, 1726, 180, 705, 1060, 2464, 47, 130, 507,
1948, 2196, 1944, 1353, 1642, 889, 2235, 567, 2061, 551, 1106, 1877,
2341, 244, 2789, 2328, 1461, 1308, 1341, 920, 1526, 1533, 2453, 2385,
1933, 1136, 2435, 1599};
q31_t q31_b_array[ROWS * COLUMNS] = {
1053, 2818, 2628, 1651, 1868, 1762, 624, 904, 1413, 692, 2533, 585,
678, 513, 683, 1308, 934, 2771, 1291, 555, 2715, 2940, 1317, 334,
775, 1227, 1785, 787, 1809, 2134, 666, 353, 891, 957, 1273, 1524,
257, 788, 2404, 88, 2787, 2191, 1466, 1736, 712, 1377, 2890, 1641,
1564, 695, 1467, 1873, 2038, 1187, 1103, 2964, 114, 2656, 2740, 2389,
297, 786, 1007, 2040, 410, 2164, 321, 1962, 1483, 2338, 2146, 2712,
2673, 1003, 2097, 594, 92, 2233, 1501, 1440, 2715, 1830, 1853, 2579,
2417, 1731, 549, 720, 2660, 87, 1470, 504, 2937, 2139, 1502, 1414,
179, 2046, 128, 215};
q31_t q31_output[ROWS * COLUMNS];
q31_t q31_output_back[ROWS * COLUMNS];
q31_t q31_output_ref[ROWS * COLUMNS];

148
examples/dsp/MatrixFunctions_q31Part/main.c Normal file
View file

@ -0,0 +1,148 @@
//
// Created by lujun on 19-6-28.
//
// This contains f32, q31 and q15 versions of matrix
// each one has it's own function.
// All function can be found in main function.
// If you don't want to use it, then comment it.
#include "riscv_math.h"
#include "array.h"
#include <stdint.h>
#include <stdlib.h>
#include "../common.h"
#include "../HelperFunctions/math_helper.c"
#include "../HelperFunctions/ref_helper.c"
#include <stdio.h>
#define DELTAF32 (0.05f)
#define DELTAQ31 (63)
#define DELTAQ15 (1)
#define DELTAQ7 (1)
int test_flag_error = 0;
int DSP_matrix_q31(void)
{
riscv_matrix_instance_q31 q31_A;
riscv_matrix_instance_q31 q31_B;
riscv_matrix_instance_q31 q31_ref;
riscv_matrix_instance_q31 q31_des;
int i;
riscv_mat_init_q31(&q31_A, ROWS, COLUMNS, (q31_t *)q31_a_array);
riscv_mat_init_q31(&q31_B, ROWS, COLUMNS, (q31_t *)q31_b_array);
riscv_mat_init_q31(&q31_des, ROWS, COLUMNS, q31_output);
riscv_mat_init_q31(&q31_ref, ROWS, COLUMNS, q31_output_ref);
// **************** q31 *********************
// add
BENCH_START(riscv_mat_add_q31);
riscv_mat_add_q31(&q31_A, &q31_B, &q31_des);
BENCH_END(riscv_mat_add_q31);
ref_mat_add_q31(&q31_A, &q31_B, &q31_ref);
for (int i = 0; i < (ROWS * COLUMNS); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_add_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_add_q31);
// mult
BENCH_START(riscv_mat_mult_q31);
riscv_mat_mult_q31(&q31_A, &q31_B, &q31_des);
BENCH_END(riscv_mat_mult_q31);
ref_mat_mult_q31(&q31_A, &q31_B, &q31_ref);
for (int i = 0; i < (ROWS * COLUMNS); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_mult_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_mult_q31);
// sub
BENCH_START(riscv_mat_sub_q31);
riscv_mat_sub_q31(&q31_A, &q31_B, &q31_des);
BENCH_END(riscv_mat_sub_q31);
ref_mat_sub_q31(&q31_A, &q31_B, &q31_ref);
for (int i = 0; i < (ROWS * COLUMNS); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_sub_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_sub_q31);
// trans
BENCH_START(riscv_mat_trans_q31);
riscv_mat_trans_q31(&q31_A, &q31_des);
BENCH_END(riscv_mat_trans_q31);
ref_mat_trans_q31(&q31_A, &q31_ref);
for (int i = 0; i < (ROWS * COLUMNS); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_trans_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_trans_q31);
// scale
BENCH_START(riscv_mat_scale_q31);
riscv_mat_scale_q31(&q31_A, 8, 2, &q31_des);
BENCH_END(riscv_mat_scale_q31);
ref_mat_scale_q31(&q31_A, 8, 2, &q31_ref);
for (int i = 0; i < (ROWS * COLUMNS); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_scale_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_scale_q31);
// cmplx_mult
riscv_mat_init_q31(&q31_A, 32, 32, (q31_t *)q31_a_array);
riscv_mat_init_q31(&q31_B, 32, 32, (q31_t *)q31_b_array);
riscv_mat_init_q31(&q31_des, 32, 32, q31_output);
riscv_mat_init_q31(&q31_ref, 32, 32, q31_output_ref);
BENCH_START(riscv_mat_cmplx_mult_q31);
riscv_mat_cmplx_mult_q31(&q31_A, &q31_B, &q31_des);
BENCH_END(riscv_mat_cmplx_mult_q31);
ref_mat_cmplx_mult_q31(&q31_A, &q31_B, &q31_ref);
for (int i = 0; i < (32 * 32); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_cmplx_mult_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_cmplx_mult_q31);
// mult_fast
BENCH_START(riscv_mat_mult_fast_q31);
riscv_mat_mult_fast_q31(&q31_A, &q31_B, &q31_des);
BENCH_END(riscv_mat_mult_fast_q31);
ref_mat_mult_fast_q31(&q31_A, &q31_B, &q31_ref);
for (int i = 0; i < (ROWS * COLUMNS); i++)
if (labs(q31_output[i] - q31_output_ref[i]) > DELTAQ31) {
BENCH_ERROR(riscv_mat_mult_fast_q31);
printf("index: %d,expect: %x, actual: %x\n", i, q31_output_ref[i],
q31_output[i]);
test_flag_error = 1;
}
BENCH_STATUS(riscv_mat_mult_fast_q31);
printf("all tests are passed,well done!\n");
}
int main()
{
BENCH_INIT;
DSP_matrix_q31();
BENCH_FINISH;
if (test_flag_error) {
printf("test error apprears, please recheck.\n");
return 1;
} else {
printf("all test are passed. Well done!\n");
}
return 0;
}

52
examples/dsp/MatrixFunctions_q31Part/mat_add.c Normal file
View file

@ -0,0 +1,52 @@
#include "ref.h"
riscv_status ref_mat_add_f32(const riscv_matrix_instance_f32 *pSrcA,
const riscv_matrix_instance_f32 *pSrcB,
riscv_matrix_instance_f32 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrcA->numRows * pSrcA->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = pSrcA->pData[i] + pSrcB->pData[i];
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_add_q31(const riscv_matrix_instance_q31 *pSrcA,
const riscv_matrix_instance_q31 *pSrcB,
riscv_matrix_instance_q31 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrcA->numRows * pSrcA->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = ref_sat_q31((q63_t)pSrcA->pData[i] + pSrcB->pData[i]);
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_add_q15(const riscv_matrix_instance_q15 *pSrcA,
const riscv_matrix_instance_q15 *pSrcB,
riscv_matrix_instance_q15 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrcA->numRows * pSrcA->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = ref_sat_q15((q31_t)pSrcA->pData[i] + pSrcB->pData[i]);
}
return RISCV_MATH_SUCCESS;
}

114
examples/dsp/MatrixFunctions_q31Part/mat_cmplx_mult.c Normal file
View file

@ -0,0 +1,114 @@
#include "ref.h"
//#include "riscv_math.h"
//#include "../common.h"
//#include "../HelperFunctions/ref_helper.c"
//#include "FastMathFunctions.c"
// /#include <stdio.h>
#define DELTA (0.05f)
riscv_status ref_mat_cmplx_mult_f32(const riscv_matrix_instance_f32 *pSrcA,
const riscv_matrix_instance_f32 *pSrcB,
riscv_matrix_instance_f32 *pDst)
{
uint32_t r, c, i, outR, outC, innerSize;
float32_t sumR, sumI;
float32_t a0, b0, c0, d0;
outR = pSrcA->numRows;
outC = pSrcB->numCols;
innerSize = pSrcA->numCols;
for (r = 0; r < outR; r++) {
for (c = 0; c < outC; c++) {
sumR = 0;
sumI = 0;
for (i = 0; i < innerSize; i++) {
a0 = pSrcA->pData[2 * (r * innerSize + i) + 0];
b0 = pSrcA->pData[2 * (r * innerSize + i) + 1];
c0 = pSrcB->pData[2 * (i * outC + c) + 0];
d0 = pSrcB->pData[2 * (i * outC + c) + 1];
sumR += a0 * c0 - b0 * d0;
sumI += b0 * c0 + a0 * d0;
}
pDst->pData[2 * (r * outC + c) + 0] = sumR;
pDst->pData[2 * (r * outC + c) + 1] = sumI;
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_cmplx_mult_q31(const riscv_matrix_instance_q31 *pSrcA,
const riscv_matrix_instance_q31 *pSrcB,
riscv_matrix_instance_q31 *pDst)
{
uint32_t r, c, i, outR, outC, innerSize;
q63_t sumR, sumI;
q31_t a0, b0, c0, d0;
outR = pSrcA->numRows;
outC = pSrcB->numCols;
innerSize = pSrcA->numCols;
for (r = 0; r < outR; r++) {
for (c = 0; c < outC; c++) {
sumR = 0;
sumI = 0;
for (i = 0; i < innerSize; i++) {
a0 = pSrcA->pData[2 * (r * innerSize + i) + 0];
b0 = pSrcA->pData[2 * (r * innerSize + i) + 1];
c0 = pSrcB->pData[2 * (i * outC + c) + 0];
d0 = pSrcB->pData[2 * (i * outC + c) + 1];
sumR += (q63_t)a0 * c0 - (q63_t)b0 * d0;
sumI += (q63_t)b0 * c0 + (q63_t)a0 * d0;
}
pDst->pData[2 * (r * outC + c) + 0] = ref_sat_q31(sumR >> 31);
pDst->pData[2 * (r * outC + c) + 1] = ref_sat_q31(sumI >> 31);
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_cmplx_mult_q15(const riscv_matrix_instance_q15 *pSrcA,
const riscv_matrix_instance_q15 *pSrcB,
riscv_matrix_instance_q15 *pDst)
{
uint32_t r, c, i, outR, outC, innerSize;
q63_t sumR, sumI;
q15_t a0, b0, c0, d0;
outR = pSrcA->numRows;
outC = pSrcB->numCols;
innerSize = pSrcA->numCols;
for (r = 0; r < outR; r++) {
for (c = 0; c < outC; c++) {
sumR = 0;
sumI = 0;
for (i = 0; i < innerSize; i++) {
a0 = pSrcA->pData[2 * (r * innerSize + i) + 0];
b0 = pSrcA->pData[2 * (r * innerSize + i) + 1];
c0 = pSrcB->pData[2 * (i * outC + c) + 0];
d0 = pSrcB->pData[2 * (i * outC + c) + 1];
sumR += (q31_t)a0 * c0 - (q31_t)b0 * d0;
sumI += (q31_t)b0 * c0 + (q31_t)a0 * d0;
}
pDst->pData[2 * (r * outC + c) + 0] = ref_sat_q15(sumR >> 15);
pDst->pData[2 * (r * outC + c) + 1] = ref_sat_q15(sumI >> 15);
}
}
return RISCV_MATH_SUCCESS;
}

54
examples/dsp/MatrixFunctions_q31Part/mat_inverse.c Normal file
View file

@ -0,0 +1,54 @@
#include "ref.h"
riscv_status ref_mat_inverse_f32(const riscv_matrix_instance_f32 *pSrc,
riscv_matrix_instance_f32 *pDst)
{
float32_t det;
uint32_t i, size;
riscv_matrix_instance_f32 tmp;
tmp.numCols = pSrc->numCols;
tmp.numRows = pSrc->numRows;
tmp.pData = scratchArray;
det = ref_detrm(pSrc->pData, scratchArray, pSrc->numCols);
size = pSrc->numCols * pSrc->numCols;
ref_cofact(pSrc->pData, scratchArray, scratchArray + size, pSrc->numCols);
ref_mat_trans_f32(&tmp, pDst);
for (i = 0; i < size; i++) {
pDst->pData[i] /= det;
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_inverse_f64(const riscv_matrix_instance_f64 *pSrc,
riscv_matrix_instance_f64 *pDst)
{
float64_t det;
uint32_t i, size;
riscv_matrix_instance_f64 tmp;
tmp.numCols = pSrc->numCols;
tmp.numRows = pSrc->numRows;
tmp.pData = (float64_t *)scratchArray;
det = ref_detrm64(pSrc->pData, (float64_t *)scratchArray, pSrc->numCols);
size = pSrc->numCols * pSrc->numCols;
ref_cofact64(pSrc->pData, (float64_t *)scratchArray,
(float64_t *)scratchArray + size, pSrc->numCols);
ref_mat_trans_f64(&tmp, pDst);
for (i = 0; i < size; i++) {
pDst->pData[i] /= det;
}
return RISCV_MATH_SUCCESS;
}

82
examples/dsp/MatrixFunctions_q31Part/mat_mult.c Normal file
View file

@ -0,0 +1,82 @@
#include "ref.h"
riscv_status ref_mat_mult_f32(const riscv_matrix_instance_f32 *pSrcA,
const riscv_matrix_instance_f32 *pSrcB,
riscv_matrix_instance_f32 *pDst)
{
uint32_t r, c, i, outR, outC, innerSize;
float32_t sum;
outR = pSrcA->numRows;
outC = pSrcB->numCols;
innerSize = pSrcA->numCols;
for (r = 0; r < outR; r++) {
for (c = 0; c < outC; c++) {
sum = 0;
for (i = 0; i < innerSize; i++) {
sum += pSrcA->pData[r * innerSize + i] *
pSrcB->pData[i * outC + c];
}
pDst->pData[r * outC + c] = sum;
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_mult_q31(const riscv_matrix_instance_q31 *pSrcA,
const riscv_matrix_instance_q31 *pSrcB,
riscv_matrix_instance_q31 *pDst)
{
uint32_t r, c, i, outR, outC, innerSize;
q63_t sum;
outR = pSrcA->numRows;
outC = pSrcB->numCols;
innerSize = pSrcA->numCols;
for (r = 0; r < outR; r++) {
for (c = 0; c < outC; c++) {
sum = 0;
for (i = 0; i < innerSize; i++) {
sum += (q63_t)(pSrcA->pData[r * innerSize + i]) *
pSrcB->pData[i * outC + c];
}
pDst->pData[r * outC + c] = ref_sat_q31(sum >> 31);
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_mult_q15(const riscv_matrix_instance_q15 *pSrcA,
const riscv_matrix_instance_q15 *pSrcB,
riscv_matrix_instance_q15 *pDst)
{
uint32_t r, c, i, outR, outC, innerSize;
q63_t sum;
outR = pSrcA->numRows;
outC = pSrcB->numCols;
innerSize = pSrcA->numCols;
for (r = 0; r < outR; r++) {
for (c = 0; c < outC; c++) {
sum = 0;
for (i = 0; i < innerSize; i++) {
sum += (q31_t)(pSrcA->pData[r * innerSize + i]) *
pSrcB->pData[i * outC + c];
}
pDst->pData[r * outC + c] = ref_sat_q15(sum >> 15);
}
}
return RISCV_MATH_SUCCESS;
}

54
examples/dsp/MatrixFunctions_q31Part/mat_scale.c Normal file
View file

@ -0,0 +1,54 @@
#include "ref.h"
riscv_status ref_mat_scale_f32(const riscv_matrix_instance_f32 *pSrc,
float32_t scale, riscv_matrix_instance_f32 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrc->numRows * pSrc->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = pSrc->pData[i] * scale;
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_scale_q31(const riscv_matrix_instance_q31 *pSrc, q31_t scale,
int32_t shift, riscv_matrix_instance_q31 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
int32_t totShift = shift + 1;
q31_t tmp;
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrc->numRows * pSrc->numCols;
for (i = 0; i < numSamples; i++) {
tmp = ((q63_t)pSrc->pData[i] * scale) >> 32;
pDst->pData[i] = ref_sat_q31((q63_t)tmp << totShift);
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_scale_q15(const riscv_matrix_instance_q15 *pSrc, q15_t scale,
int32_t shift, riscv_matrix_instance_q15 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
int32_t totShift = 15 - shift;
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrc->numRows * pSrc->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] =
ref_sat_q15(((q31_t)pSrc->pData[i] * scale) >> totShift);
}
return RISCV_MATH_SUCCESS;
}

53
examples/dsp/MatrixFunctions_q31Part/mat_sub.c Normal file
View file

@ -0,0 +1,53 @@
#include "ref.h"
//#include "../HelperFunctions/ref_helper.c"
riscv_status ref_mat_sub_f32(const riscv_matrix_instance_f32 *pSrcA,
const riscv_matrix_instance_f32 *pSrcB,
riscv_matrix_instance_f32 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrcA->numRows * pSrcA->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = pSrcA->pData[i] - pSrcB->pData[i];
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_sub_q31(const riscv_matrix_instance_q31 *pSrcA,
const riscv_matrix_instance_q31 *pSrcB,
riscv_matrix_instance_q31 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrcA->numRows * pSrcA->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = ref_sat_q31((q63_t)pSrcA->pData[i] - pSrcB->pData[i]);
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_sub_q15(const riscv_matrix_instance_q15 *pSrcA,
const riscv_matrix_instance_q15 *pSrcB,
riscv_matrix_instance_q15 *pDst)
{
uint32_t i;
uint32_t numSamples; /* total number of elements in the matrix */
/* Total number of samples in the input matrix */
numSamples = (uint32_t)pSrcA->numRows * pSrcA->numCols;
for (i = 0; i < numSamples; i++) {
pDst->pData[i] = ref_sat_q15((q31_t)pSrcA->pData[i] - pSrcB->pData[i]);
}
return RISCV_MATH_SUCCESS;
}

65
examples/dsp/MatrixFunctions_q31Part/mat_trans.c Normal file
View file

@ -0,0 +1,65 @@
#include "ref.h"
riscv_status ref_mat_trans_f64(const riscv_matrix_instance_f64 *pSrc,
riscv_matrix_instance_f64 *pDst)
{
uint64_t r, c;
uint64_t numR = pSrc->numRows;
uint64_t numC = pSrc->numCols;
for (r = 0; r < numR; r++) {
for (c = 0; c < numC; c++) {
pDst->pData[c * numR + r] = pSrc->pData[r * numC + c];
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_trans_f32(const riscv_matrix_instance_f32 *pSrc,
riscv_matrix_instance_f32 *pDst)
{
uint32_t r, c;
uint32_t numR = pSrc->numRows;
uint32_t numC = pSrc->numCols;
for (r = 0; r < numR; r++) {
for (c = 0; c < numC; c++) {
pDst->pData[c * numR + r] = pSrc->pData[r * numC + c];
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_trans_q31(const riscv_matrix_instance_q31 *pSrc,
riscv_matrix_instance_q31 *pDst)
{
uint32_t r, c;
uint32_t numR = pSrc->numRows;
uint32_t numC = pSrc->numCols;
for (r = 0; r < numR; r++) {
for (c = 0; c < numC; c++) {
pDst->pData[c * numR + r] = pSrc->pData[r * numC + c];
}
}
return RISCV_MATH_SUCCESS;
}
riscv_status ref_mat_trans_q15(const riscv_matrix_instance_q15 *pSrc,
riscv_matrix_instance_q15 *pDst)
{
uint32_t r, c;
uint32_t numR = pSrc->numRows;
uint32_t numC = pSrc->numCols;
for (r = 0; r < numR; r++) {
for (c = 0; c < numC; c++) {
pDst->pData[c * numR + r] = pSrc->pData[r * numC + c];
}
}
return RISCV_MATH_SUCCESS;
}