148 lines
5.3 KiB
C
148 lines
5.3 KiB
C
#include "riscv_math.h"
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include "array.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 main()
|
|
{
|
|
int i;
|
|
|
|
// Noticing that all the following functions are in Big-end!
|
|
|
|
BENCH_INIT;
|
|
float32_t f32_output, f32_output_ref = 0.282051282051282;
|
|
//1.0*(ctf + cft) / (2.0*ctt + cft + ctf)
|
|
//t stands for true,f stands for false
|
|
BENCH_START(riscv_dice_distance);
|
|
f32_output = riscv_dice_distance(u32_dice_a_array, u32_dice_b_array, 36);
|
|
BENCH_END(riscv_dice_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_dice_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_dice_distance);
|
|
|
|
f32_output_ref = 0.583333333333333;
|
|
//1.0*(ctf + cft) / numberOfBools
|
|
BENCH_START(riscv_hamming_distance);
|
|
f32_output = riscv_hamming_distance(u32_hamming_a_array, u32_hamming_b_array, 36);
|
|
BENCH_END(riscv_hamming_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_hamming_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_hamming_distance);
|
|
|
|
f32_output_ref = 0.769230769230769;
|
|
//1.0*(ctf + cft) / (ctt + cft + ctf)
|
|
BENCH_START(riscv_jaccard_distance);
|
|
f32_output = riscv_jaccard_distance(u32_jaccard_a_array, u32_jaccard_b_array, 36);
|
|
BENCH_END(riscv_jaccard_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_jaccard_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_jaccard_distance);
|
|
|
|
f32_output_ref = 0.894736842105263;
|
|
//1.0*(ctf + cft - ctt + numberOfBools) / (cft + ctf + numberOfBools)
|
|
BENCH_START(riscv_kulsinski_distance);
|
|
f32_output = riscv_kulsinski_distance(u32_kulsinski_a_array, u32_kulsinski_b_array, 36);
|
|
BENCH_END(riscv_kulsinski_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_kulsinski_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_kulsinski_distance);
|
|
|
|
f32_output_ref = 0.615384615384615;
|
|
//r = 2*(ctf + cft)
|
|
//return(1.0*r / (r + ctt + cff))
|
|
BENCH_START(riscv_rogerstanimoto_distance);
|
|
f32_output = riscv_rogerstanimoto_distance(u32_rogerstanimoto_a_array, u32_rogerstanimoto_b_array, 36);
|
|
BENCH_END(riscv_rogerstanimoto_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_rogerstanimoto_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_rogerstanimoto_distance);
|
|
|
|
f32_output_ref = 0.833333333333333;
|
|
//1.0*(numberOfBools - ctt) / ((float32_t)numberOfBools)
|
|
BENCH_START(riscv_russellrao_distance);
|
|
f32_output = riscv_russellrao_distance(u32_russellrao_a_array, u32_russellrao_b_array, 36);
|
|
BENCH_END(riscv_russellrao_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_russellrao_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_russellrao_distance);
|
|
|
|
f32_output_ref = 0.714285714285714;
|
|
//r = 2.0*(ctf + cft);
|
|
//s = 1.0*(cff + ctt);
|
|
//r / (s+r)
|
|
BENCH_START(riscv_sokalmichener_distance);
|
|
f32_output = riscv_sokalmichener_distance(u32_sokalmichener_a_array, u32_sokalmichener_b_array, 36);
|
|
BENCH_END(riscv_sokalmichener_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_sokalmichener_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_sokalmichener_distance);
|
|
|
|
f32_output_ref = 0.790697674418605;
|
|
//r = 2.0*(ctf + cft);
|
|
//r / (r + ctt)
|
|
BENCH_START(riscv_sokalsneath_distance);
|
|
f32_output = riscv_sokalsneath_distance(u32_sokalsneath_a_array, u32_sokalsneath_b_array, 36);
|
|
BENCH_END(riscv_sokalsneath_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_sokalsneath_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_sokalsneath_distance);
|
|
|
|
f32_output_ref = 1.26760563380282;
|
|
//r = 2*(ctf * cft);
|
|
//1.0*r / (r/2.0 + ctt * cff)
|
|
BENCH_START(riscv_yule_distance);
|
|
f32_output = riscv_yule_distance(u32_yule_a_array, u32_yule_b_array, 36);
|
|
BENCH_END(riscv_yule_distance);
|
|
if (fabs(f32_output - f32_output_ref) > DELTAF32) {
|
|
BENCH_ERROR(riscv_yule_distance);
|
|
printf("expect: %f, actual: %f\n", f32_output_ref, f32_output);
|
|
test_flag_error = 1;
|
|
}
|
|
BENCH_STATUS(riscv_yule_distance);
|
|
|
|
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;
|
|
};
|