Class which collects generic mathematical functions.
Public Member Functions |
virtual const char * | get_name () const |
template<> |
void | display_vector (const uint8_t *vector, int32_t n, const char *name) |
template<> |
void | display_vector (const int32_t *vector, int32_t n, const char *name) |
template<> |
void | display_vector (const int64_t *vector, int32_t n, const char *name) |
template<> |
void | display_vector (const uint64_t *vector, int32_t n, const char *name) |
template<> |
void | display_vector (const float32_t *vector, int32_t n, const char *name) |
template<> |
void | display_vector (const float64_t *vector, int32_t n, const char *name) |
template<> |
void | display_vector (const floatmax_t *vector, int32_t n, const char *name) |
template<> |
void | display_matrix (const int32_t *matrix, int32_t rows, int32_t cols, const char *name) |
template<> |
void | display_matrix (const float64_t *matrix, int32_t rows, int32_t cols, const char *name) |
template<> |
void | display_matrix (const float32_t *matrix, int32_t rows, int32_t cols, const char *name) |
|
|
| CMath () |
| Constructor - initializes log-table.
|
virtual | ~CMath () |
| Destructor - frees logtable.
|
Static Public Member Functions |
static float64_t | mutual_info (float64_t *p1, float64_t *p2, int32_t len) |
static float64_t | relative_entropy (float64_t *p, float64_t *q, int32_t len) |
static float64_t | entropy (float64_t *p, int32_t len) |
| returns entropy of p which is given in logspace
|
static uint32_t | get_seed () |
| returns number generator seed
|
static uint32_t | get_log_range () |
| returns range of logtable
|
static int | is_finite (double f) |
| checks whether a float is finite
|
static int | is_infinity (double f) |
| checks whether a float is infinity
|
static int | is_nan (double f) |
| checks whether a float is nan
|
static SGVector< float64_t > | fishers_exact_test_for_multiple_2x3_tables (SGMatrix< float64_t > tables) |
static float64_t | fishers_exact_test_for_2x3_table (SGMatrix< float64_t > table) |
|
|
template<class T > |
static T | min (T a, T b) |
| return the minimum of two integers
|
template<class T > |
static T | max (T a, T b) |
| return the maximum of two integers
|
template<class T > |
static T | clamp (T value, T lb, T ub) |
| return the value clamped to interval [lb,ub]
|
template<class T > |
static T | abs (T a) |
| return the absolute value of a number
|
|
|
static float64_t | round (float64_t d) |
static float64_t | floor (float64_t d) |
static float64_t | ceil (float64_t d) |
template<class T > |
static T | sign (T a) |
| signum of type T variable a
|
template<class T > |
static void | swap (T &a, T &b) |
| swap e.g. floats a and b
|
template<class T > |
static void | resize (T *&data, int64_t old_size, int64_t new_size) |
template<class T > |
static T | twonorm (T *x, int32_t len) |
| || x ||_2
|
template<class T > |
static T | qsq (T *x, int32_t len, float64_t q) |
| || x ||_q^q
|
template<class T > |
static T | qnorm (T *x, int32_t len, float64_t q) |
| || x ||_q
|
template<class T > |
static T | sq (T x) |
| x^2
|
static float32_t | sqrt (float32_t x) |
| x^0.5
|
static float64_t | sqrt (float64_t x) |
| x^0.5
|
static floatmax_t | sqrt (floatmax_t x) |
| x^0.5
|
static float32_t | invsqrt (float32_t x) |
| x^-0.5
|
static floatmax_t | powl (floatmax_t x, floatmax_t n) |
| x^n
|
static int32_t | pow (int32_t x, int32_t n) |
static float64_t | pow (float64_t x, int32_t n) |
static float64_t | pow (float64_t x, float64_t n) |
static float64_t | exp (float64_t x) |
static float64_t | lgamma (float64_t x) |
static float64_t | tgamma (float64_t x) |
static float64_t | atan (float64_t x) |
static floatmax_t | lgammal (floatmax_t x) |
static float64_t | log10 (float64_t v) |
static float64_t | log2 (float64_t v) |
static float64_t | log (float64_t v) |
static float64_t | area_under_curve (float64_t *xy, int32_t len, bool reversed) |
template<class T > |
static void | transpose_matrix (T *&matrix, int32_t &num_feat, int32_t &num_vec) |
static float64_t * | pinv (float64_t *matrix, int32_t rows, int32_t cols, float64_t *target=NULL) |
static void | dgemm (double alpha, const double *A, int rows, int cols, CBLAS_TRANSPOSE transposeA, double *B, int cols_B, CBLAS_TRANSPOSE transposeB, double beta, double *C) |
static void | dgemv (double alpha, const double *A, int rows, int cols, const CBLAS_TRANSPOSE transposeA, const double *X, double beta, double *Y) |
static int64_t | factorial (int32_t n) |
static void | init_random (uint32_t initseed=0) |
static int64_t | random () |
static int32_t | random (int32_t min_value, int32_t max_value) |
static float32_t | random (float32_t min_value, float32_t max_value) |
static float64_t | random (float64_t min_value, float64_t max_value) |
static float32_t | normal_random (float32_t mean, float32_t std_dev) |
static float64_t | normal_random (float64_t mean, float64_t std_dev) |
static float32_t | randn_float () |
static float64_t | randn_double () |
template<class T > |
static T * | clone_vector (const T *vec, int32_t len) |
template<class T > |
static void | fill_vector (T *vec, int32_t len, T value) |
template<class T > |
static void | range_fill_vector (T *vec, int32_t len, T start=0) |
template<class T > |
static void | random_vector (T *vec, int32_t len, T min_value, T max_value) |
static int32_t * | randperm (int32_t n) |
static int64_t | nchoosek (int32_t n, int32_t k) |
template<class T > |
static void | vec1_plus_scalar_times_vec2 (T *vec1, T scalar, const T *vec2, int32_t n) |
| x=x+alpha*y
|
static float64_t | dot (const bool *v1, const bool *v2, int32_t n) |
| compute dot product between v1 and v2 (blas optimized)
|
static floatmax_t | dot (const floatmax_t *v1, const floatmax_t *v2, int32_t n) |
| compute dot product between v1 and v2 (blas optimized)
|
static float64_t | dot (const float64_t *v1, const float64_t *v2, int32_t n) |
| compute dot product between v1 and v2 (blas optimized)
|
static float32_t | dot (const float32_t *v1, const float32_t *v2, int32_t n) |
| compute dot product between v1 and v2 (blas optimized)
|
static float64_t | dot (const uint64_t *v1, const uint64_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 64bit unsigned ints)
|
static float64_t | dot (const int64_t *v1, const int64_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 64bit ints)
|
static float64_t | dot (const int32_t *v1, const int32_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 32bit ints)
|
static float64_t | dot (const uint32_t *v1, const uint32_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 32bit unsigned ints)
|
static float64_t | dot (const uint16_t *v1, const uint16_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 16bit unsigned ints)
|
static float64_t | dot (const int16_t *v1, const int16_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 16bit unsigned ints)
|
static float64_t | dot (const char *v1, const char *v2, int32_t n) |
| compute dot product between v1 and v2 (for 8bit (un)signed ints)
|
static float64_t | dot (const uint8_t *v1, const uint8_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 8bit (un)signed ints)
|
static float64_t | dot (const int8_t *v1, const int8_t *v2, int32_t n) |
| compute dot product between v1 and v2 (for 8bit (un)signed ints)
|
static float64_t | dot (const float64_t *v1, const char *v2, int32_t n) |
| compute dot product between v1 and v2
|
template<class T > |
static void | vector_multiply (T *target, const T *v1, const T *v2, int32_t len) |
| compute vector multiplication
|
template<class T > |
static void | add (T *target, T alpha, const T *v1, T beta, const T *v2, int32_t len) |
| target=alpha*vec1 + beta*vec2
|
template<class T > |
static void | add_scalar (T alpha, T *vec, int32_t len) |
| add scalar to vector inplace
|
template<class T > |
static void | scale_vector (T alpha, T *vec, int32_t len) |
| scale vector inplace
|
template<class T > |
static T | sum (T *vec, int32_t len) |
| return sum(vec)
|
template<class T > |
static T | max (T *vec, int32_t len) |
| return max(vec)
|
template<class T > |
static T | sum_abs (T *vec, int32_t len) |
| return sum(abs(vec))
|
template<class T > |
static bool | fequal (T x, T y, float64_t precision=1e-6) |
| return sum(abs(vec))
|
static float64_t | mean (float64_t *vec, int32_t len) |
static float64_t | trace (float64_t *mat, int32_t cols, int32_t rows) |
static void | sort (int32_t *a, int32_t cols, int32_t sort_col=0) |
static void | sort (float64_t *a, int32_t *idx, int32_t N) |
template<class T > |
static void | radix_sort (T *array, int32_t size) |
template<class T > |
static uint8_t | byte (T word, uint16_t p) |
template<class T > |
static void | radix_sort_helper (T *array, int32_t size, uint16_t i) |
template<class T > |
static void | insertion_sort (T *output, int32_t size) |
template<class T > |
static void | qsort (T *output, int32_t size) |
template<class T > |
static void | qsort (SGVector< T * > array) |
template<class T > |
static void | display_bits (T word, int32_t width=8 *sizeof(T)) |
| display bits (useful for debugging)
|
template<class T > |
static void | display_vector (const T *vector, int32_t n, const char *name="vector") |
| display vector (useful for debugging)
|
template<class T > |
static void | display_matrix (const T *matrix, int32_t rows, int32_t cols, const char *name="matrix") |
| display matrix (useful for debugging)
|
template<class T1 , class T2 > |
static void | qsort_index (T1 *output, T2 *index, uint32_t size) |
template<class T1 , class T2 > |
static void | qsort_backward_index (T1 *output, T2 *index, int32_t size) |
template<class T1 , class T2 > |
static void | parallel_qsort_index (T1 *output, T2 *index, uint32_t size, int32_t n_threads, int32_t limit=262144) |
template<class T1 , class T2 > |
static void * | parallel_qsort_index (void *p) |
template<class T > |
static void | min (float64_t *output, T *index, int32_t size) |
template<class T > |
static void | nmin (float64_t *output, T *index, int32_t size, int32_t n) |
template<class T > |
static int32_t | unique (T *output, int32_t size) |
static double * | compute_eigenvectors (double *matrix, int n, int m) |
template<class T > |
static T * | get_row_sum (T *matrix, int32_t m, int32_t n) |
template<class T > |
static T * | get_column_sum (T *matrix, int32_t m, int32_t n) |
template<class T > |
static void | center_matrix (T *matrix, int32_t m, int32_t n) |
template<class T > |
static int32_t | binary_search_helper (T *output, int32_t size, T elem) |
template<class T > |
static int32_t | binary_search (T *output, int32_t size, T elem) |
template<class T > |
static int32_t | binary_search (SGVector< T * > array, T *elem) |
template<class T > |
static int32_t | binary_search_max_lower_equal (T *output, int32_t size, T elem) |
static float64_t | Align (char *seq1, char *seq2, int32_t l1, int32_t l2, float64_t gapCost) |
|
|
static float64_t | logarithmic_sum (float64_t p, float64_t q) |
constants |
|
static const float64_t | INFTY = -log(0.0) |
| infinity
|
static const float64_t | ALMOST_INFTY = +1e+20 |
static const float64_t | ALMOST_NEG_INFTY = -1000 |
| almost neg (log) infinity
|
static const float64_t | PI = PI |
static const float64_t | MACHINE_EPSILON = 5E-16 |
static const float64_t | MAX_REAL_NUMBER = 1E300 |
static const float64_t | MIN_REAL_NUMBER = 1E-300 |
static int32_t | LOGRANGE = 0 |
| range for logtable: log(1+exp(x)) -LOGRANGE <= x <= 0
|
static uint32_t | seed = 0 |
| random generator seed
|
static char * | rand_state = NULL |