MathFunctions.cpp

Go to the documentation of this file.

// copyright (c) 2004 by Christos Dimitrakakis <dimitrak@idiap.ch>
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include <learning/MathFunctions.h>
#include <cmath>
#include <cassert>

 
int ArgMin (int n, real* x)
{
    real min = x[0];
    int arg_min = 0;
    for (int i=1; i<n; i++) {
    if (min>x[i]) {
        min = x[i];
        arg_min = i;
    }
    }
    return arg_min;
}
int ArgMax (int n, real* x)
{
    real max = x[0];
    int arg_max = 0;
    for (int i=1; i<n; i++) {
    if (max<x[i]) {
        max = x[i];
        arg_max = i;
    }
    }
    return arg_max;
}
 
void SoftMax (int n, real* Q, real* p, real beta)
{
    real sum = 0.0;
    int i;
    for (i=0; i<n; i++) {
        p[i] = (real) exp (beta * Q[i]);
        sum += p[i];
    }
    sum = 1.0f/sum;
    for (i=0; i<n; i++) {
        p[i] *= sum;
    }
}
    
void SoftMin (int n, real* Q, real* p, real beta)
{
    real sum = 0.0f;
    int i;
    for (i=0; i<n; i++) {
        p[i] = (real) exp (-beta * Q[i]);
        sum += p[i];
    }
    sum = 1.0f/sum;
    for (i=0; i<n; i++) {
        p[i] *= sum;
    }
}
    

real SmoothMaxGamma (real f1, real f2, real lambda, real c)
{
    real t = f2-f1;
    real gamma;
 
    assert(c>0);
    assert(lambda>=0 && lambda<=1);
 
    if (1-lambda/c <= t) {
        gamma = t  - (1-lambda)*(1-lambda) / (2*c);
    } else if (t>=-lambda/c) {
        gamma = lambda * t + t*t*c/2;
    } else {
        gamma = - lambda * lambda / (2*c);
    }
    return f1 + gamma;
}
 

real SmoothMaxPNorm (real f1, real f2, real p)
{
    assert(p>0);
    return (real) pow(pow(f1,p)+pow(f2,p),1/p);
}
    
void Normalise (real* src, real* dst, int n_elements)
{
    real sum = 0.0f;
    int i;
    for (i=0; i<n_elements; i++) {
        sum += src[i];
    }
    if (sum==0) {
        for (i=0; i<n_elements; i++) {
            dst[i] = src[i];
        }
        return;
    }
    assert(sum>0);
    for (i=0; i<n_elements; i++) {
        dst[i] = src[i]/sum;
    }
}
 
real SquareNorm (real* a, real* b, int n)
{
    real sum = 0;
    for (int i=0; i<n; i++) {
        real d = (*a++) - (*b++);
        sum += d*d;
    }
    return sum;
}
 
real EuclideanNorm (real* a, real* b, int n)
{
    real sum = 0;
    for (int i=0; i<n; i++) {
        real d = (*a++) - (*b++);
        sum += d*d;
    }
    return (real) sqrt(sum);
}
 
real LNorm (real* a, real* b, int n, real p)
{
    real sum = 0;
    for (int i=0; i<n; i++) {
        real d = (*a++) - (*b++);
        sum += (real) pow(d,p);
    }
    return (real) pow((double)sum,1.0/p);
}
 
real Sum (real* a, int n)
{
    real sum = 0;
    for (int i=0; i<n; i++) {
        sum += *a++;
    }
    return sum;
}