mirror of
https://github.com/IcedRooibos/py32f0-template.git
synced 2025-11-03 10:22:05 -08:00
342 lines
9.8 KiB
C
342 lines
9.8 KiB
C
/******************************************************************************
|
|
* @file distance_functions.h
|
|
* @brief Public header file for CMSIS DSP Library
|
|
* @version V1.10.0
|
|
* @date 08 July 2021
|
|
* Target Processor: Cortex-M and Cortex-A cores
|
|
******************************************************************************/
|
|
/*
|
|
* Copyright (c) 2010-2020 Arm Limited or its affiliates. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the License); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
|
|
#ifndef _DISTANCE_FUNCTIONS_H_
|
|
#define _DISTANCE_FUNCTIONS_H_
|
|
|
|
#include "arm_math_types.h"
|
|
#include "arm_math_memory.h"
|
|
|
|
#include "dsp/none.h"
|
|
#include "dsp/utils.h"
|
|
|
|
#include "dsp/statistics_functions.h"
|
|
#include "dsp/basic_math_functions.h"
|
|
#include "dsp/fast_math_functions.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif
|
|
|
|
|
|
/**
|
|
* @defgroup groupDistance Distance functions
|
|
*
|
|
* Distance functions for use with clustering algorithms.
|
|
* There are distance functions for float vectors and boolean vectors.
|
|
*
|
|
*/
|
|
|
|
/* 6.14 bug */
|
|
#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6100100) && (__ARMCC_VERSION < 6150001)
|
|
|
|
__attribute__((weak)) float __powisf2(float a, int b);
|
|
|
|
#endif
|
|
|
|
/**
|
|
* @brief Euclidean distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_euclidean_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Euclidean distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float64_t arm_euclidean_distance_f64(const float64_t *pA,const float64_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Bray-Curtis distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float32_t arm_braycurtis_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Canberra distance between two vectors
|
|
*
|
|
* This function may divide by zero when samples pA[i] and pB[i] are both zero.
|
|
* The result of the computation will be correct. So the division per zero may be
|
|
* ignored.
|
|
*
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float32_t arm_canberra_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
|
|
|
|
|
|
/**
|
|
* @brief Chebyshev distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float32_t arm_chebyshev_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
|
|
|
|
|
|
/**
|
|
* @brief Chebyshev distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float64_t arm_chebyshev_distance_f64(const float64_t *pA,const float64_t *pB, uint32_t blockSize);
|
|
|
|
|
|
/**
|
|
* @brief Cityblock (Manhattan) distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float32_t arm_cityblock_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Cityblock (Manhattan) distance between two vectors
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float64_t arm_cityblock_distance_f64(const float64_t *pA,const float64_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Correlation distance between two vectors
|
|
*
|
|
* The input vectors are modified in place !
|
|
*
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
float32_t arm_correlation_distance_f32(float32_t *pA,float32_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Cosine distance between two vectors
|
|
*
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_cosine_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Cosine distance between two vectors
|
|
*
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float64_t arm_cosine_distance_f64(const float64_t *pA,const float64_t *pB, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Jensen-Shannon distance between two vectors
|
|
*
|
|
* This function is assuming that elements of second vector are > 0
|
|
* and 0 only when the corresponding element of first vector is 0.
|
|
* Otherwise the result of the computation does not make sense
|
|
* and for speed reasons, the cases returning NaN or Infinity are not
|
|
* managed.
|
|
*
|
|
* When the function is computing x log (x / y) with x 0 and y 0,
|
|
* it will compute the right value (0) but a division per zero will occur
|
|
* and shoudl be ignored in client code.
|
|
*
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_jensenshannon_distance_f32(const float32_t *pA,const float32_t *pB,uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Minkowski distance between two vectors
|
|
*
|
|
* @param[in] pA First vector
|
|
* @param[in] pB Second vector
|
|
* @param[in] n Norm order (>= 2)
|
|
* @param[in] blockSize vector length
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
float32_t arm_minkowski_distance_f32(const float32_t *pA,const float32_t *pB, int32_t order, uint32_t blockSize);
|
|
|
|
/**
|
|
* @brief Dice distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] order Distance order
|
|
* @param[in] blockSize Number of samples
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
|
|
float32_t arm_dice_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Hamming distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_hamming_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Jaccard distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_jaccard_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Kulsinski distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_kulsinski_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Roger Stanimoto distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_rogerstanimoto_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Russell-Rao distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_russellrao_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Sokal-Michener distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_sokalmichener_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Sokal-Sneath distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_sokalsneath_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
/**
|
|
* @brief Yule distance between two vectors
|
|
*
|
|
* @param[in] pA First vector of packed booleans
|
|
* @param[in] pB Second vector of packed booleans
|
|
* @param[in] numberOfBools Number of booleans
|
|
* @return distance
|
|
*
|
|
*/
|
|
|
|
float32_t arm_yule_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* ifndef _DISTANCE_FUNCTIONS_H_ */
|