MathMatrix.hpp

/*
 * MathMatrix.hpp
 * 
 * Copyright 2018 Fernando Pujaico Rivera <fernando.pujaico.rivera@gmail.com>
 * 
 * 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.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 * 
 */
 
#ifndef __PDS_MATRIXMATH_HPP__
#define __PDS_MATRIXMATH_HPP__
 
 
#include <Pds/Matrix>
#include <Pds/Vector>
#include <Pds/RaDefines>
 
namespace Pds{
    
 
    Pds::Matrix Sin(const Pds::Matrix &A);
    
    Pds::Matrix Cos(const Pds::Matrix &A);
    
    Pds::Matrix Tan(const Pds::Matrix &A);
    Pds::Matrix Exp(const Pds::Matrix &A);
    
    Pds::Matrix TwoExp(const Pds::Matrix &A);
    
    Pds::Matrix Log(const Pds::Matrix &A);
 
    Pds::Matrix Ln(const Pds::Matrix &A);
    
    Pds::Matrix Log2(const Pds::Matrix &A);
 
    Pds::Matrix Log10(const Pds::Matrix &A);
 
    Pds::Matrix Sqrt(const Pds::Matrix &A);
 
    Pds::Matrix Pow(const Pds::Matrix &A,double var);
 
    Pds::Matrix Pow(const Pds::Matrix &A,const Pds::Matrix &B);
 
    Pds::Matrix Atan2(const Pds::Matrix &A,const Pds::Matrix &B);
    
    
    double XqHb(double p,double q);
    
    Pds::Matrix XqHb(const Pds::Matrix &A,double q);
 
    double DXqHb(double p,double q);
    
 
    Pds::Matrix DXqHb(const Pds::Matrix &A,double q);
    
    double PLog2P(double p);
 
    Pds::Matrix PLog2P(const Pds::Matrix &A);
    
    double CrossEntropy(double p,double q);
    
    Pds::Matrix CrossEntropy(const Pds::Matrix &P,const Pds::Matrix &Q);
    
    double KLDivergence(double p,double q);
 
    Pds::Matrix KLDivergence(const Pds::Matrix &P,const Pds::Matrix &Q);
    double Hb(double x);
 
    Pds::Matrix Hb(const Pds::Matrix &A);
 
    double HbInv(double h);
 
    Pds::Matrix HbInv(const Pds::Matrix &A);
    
 
    
    double Logit2(double x);
 
    Pds::Matrix Logit2(const Pds::Matrix &A);
    
    double Hbn(double x);
 
    Pds::Matrix Hbn(const Pds::Matrix &A);
 
    double qExp(double x,double q);
    
    Pds::Matrix qExp(const Pds::Matrix &A,double q);
 
    double qLog(double x,double q);
    
    Pds::Matrix qLog(const Pds::Matrix &A,double q);
    
    double qHbn(double x,double q);
    
    Pds::Matrix qHbn(const Pds::Matrix &A,double q);
    
    double qDHbn(double x,double q);
    
    Pds::Matrix qDHbn(const Pds::Matrix &A,double q);
    
    double InformationGain(const Pds::Matrix &B, const std::vector<Pds::Matrix> &A,double Umbral=0.5);
    
    Pds::Vector InformationGainScale(const Pds::Vector &Y,double Umbral=0.5);
    
    Pds::Vector InformationSumScale(const Pds::Vector &Y,double Umbral=0.5);
 
namespace CDF{
 
    double Phi(double x);
    
    double Phi(double x,double mu,double sigma);
    
    Pds::Matrix Phi(const Pds::Matrix &A);
    
    
    double Probit(double p);
    
    Pds::Matrix Probit(const Pds::Matrix &A);
}
 
 
 
    double Var(const Pds::Matrix &A, double *mean);
 
    double Var(const Pds::Matrix &A);
 
    double Mean(const Pds::Matrix &A);
 
    double Sum(const Pds::Matrix &A);
    
    double R2(const Pds::Matrix &A,const Pds::Matrix &B);
    
    double Accuracy(const Pds::Matrix &A,const Pds::Matrix &B,double Umbral=0.5);
    
    double AccuracyBatchBlock(  const Pds::BatchBlock &A,
                                const Pds::BatchBlock &B,
                                double Umbral=0.5);
    
    bool CountRoundEqualIn( const Pds::Matrix &A,
                            const Pds::Matrix &B, 
                            unsigned int &S,
                            unsigned int &T);
    
    bool CountRoundEqualInBatchBlock(   const Pds::BatchBlock &A,
                                        const Pds::BatchBlock &B, 
                                        unsigned int &S,
                                        unsigned int &T);
    
    bool SquareErrorInBatchBlock(   const Pds::BatchBlock &A,
                                    const Pds::BatchBlock &B, 
                                    double &S);
    
    double NAccuracy(const Pds::Matrix &A,const Pds::Matrix &B);
 
    
    double MeanAbsoluteError(const Pds::Matrix &A,const Pds::Matrix &B);
    double ArgMax(const Pds::Matrix &X);
    
    double ArgMin(const Pds::Matrix &X);
 
    double Det(const Pds::Matrix &A);
 
    double RMS(const Pds::Matrix &A);
 
    double MeanAbsolute(const Pds::Matrix &A);
 
    double MeanSquare(const Pds::Matrix &A);
 
 
    double SumSquare(const Pds::Matrix &A);
 
    double Norm(const Pds::Matrix &A);
    
    double NormDiff(const Pds::Matrix &A,const Pds::Matrix &B);
    
    Pds::Matrix SQNL(const Pds::Matrix &X);
    
    double SQNL(double x);
    
    Pds::Matrix DSQNL(const Pds::Matrix &X);
 
    double DSQNL(double x);
    
    Pds::Matrix Identity(const Pds::Matrix &X);
 
    double Identity(double x);
    
    Pds::Matrix DIdentity(const Pds::Matrix &X);
 
    double DIdentity(double x);
    
    Pds::Matrix SoftSign(const Pds::Matrix &X);
    
    double SoftSign(double x);
 
    
    Pds::Matrix DSoftSign(const Pds::Matrix &X);
 
    double DSoftSign(double x);
    
    Pds::Matrix ELU(const Pds::Matrix &X);
    
    double ELU(double x);
 
    
    Pds::Matrix DELU(const Pds::Matrix &X);
 
    double DELU(double x);
    
    Pds::Matrix SoftPlus(const Pds::Matrix &X);
    
    double SoftPlus(double x);
 
    
    Pds::Matrix DSoftPlus(const Pds::Matrix &X);
 
    double DSoftPlus(double x);
    
    Pds::Matrix ReLU(const Pds::Matrix &X);
    
    double ReLU(double x);
 
    
    Pds::Matrix DReLU(const Pds::Matrix &X);
 
    double DReLU(double x);
 
    
    Pds::Matrix LeakyReLU(const Pds::Matrix &X);
    
    double LeakyReLU(double x);
 
 
    Pds::Matrix DLeakyReLU(const Pds::Matrix &X);
    
    double DLeakyReLU(double x);
 
    Pds::Matrix Gaussian(const Pds::Matrix &X);
 
    double Gaussian(double x);
 
    Pds::Matrix DGaussian(const Pds::Matrix &X);
 
    double DGaussian(double x);
 
    Pds::Matrix Tanh(const Pds::Matrix &X);
 
    double Tanh(double x);
    
    Pds::Matrix DTanh(const Pds::Matrix &X);
    
    double DTanh(double x);
    
    Pds::Matrix Sigmoid(const Pds::Matrix &X);
 
    double Sigmoid(double x);
 
    Pds::Matrix DSigmoid(const Pds::Matrix &X);
    
    double DSigmoid(double x);
    
    Pds::Matrix SoftMax(const Pds::Matrix &X);
    
    Pds::Matrix HardMax(const Pds::Matrix &X);
 
    unsigned int Factorial(unsigned int n);
 
 
    unsigned int NchooseK(unsigned int n,unsigned int k);
 
    unsigned int NmultichooseK(unsigned int n,unsigned int k);
 
    double UnitStep(double x);
 
    Pds::Matrix UnitStep(const Pds::Matrix &A);
 
    double UnitRamp(double x);
 
    Pds::Matrix UnitRamp(const Pds::Matrix &A);
 
    
    double SignNZ(double x);
    
    double Sign(double x);
 
 
 
    Pds::Matrix Sign(const Pds::Matrix &A);
    
    Pds::Matrix Round(const Pds::Matrix &A);
 
 
    double MuLaw(double x,double Mu);
    
    Pds::Matrix MuLaw(const Pds::Matrix &A,double Mu);
    
    double MuLawInv(double y,double Mu);
    
    Pds::Matrix MuLawInv(const Pds::Matrix &A,double Mu);
 
    Pds::Matrix Conv2DCh(   const std::vector<Pds::Matrix> &A,
                            const std::vector<Pds::Matrix> &Kernel, 
                            const std::vector<unsigned int> &Strides={1,1},
                            Pds::Ra::Padding Padding=Pds::Ra::Valid);
    
    Pds::Vector Conv1DCh(   const std::vector<Pds::Vector> &A,
                            const std::vector<Pds::Vector> &Kernel, 
                            unsigned int Strides=1,
                            Pds::Ra::Padding Padding=Pds::Ra::Valid);
    
    Pds::Matrix Conv1DCh(   const std::vector<Pds::Matrix> &A,
                            const std::vector<Pds::Vector> &Kernel, 
                            unsigned int Strides=1,
                            Pds::Ra::Padding Padding=Pds::Ra::Valid);
    
 
    Pds::Matrix Abs(const Pds::Matrix &A);
    
    double Logit(double x);
 
    Pds::Matrix Logit(const Pds::Matrix &A);
    
    Pds::Matrix Erf(const Pds::Matrix &A);
    
    double Sinc(double x);
 
    Pds::Matrix Sinc(const Pds::Matrix &A);
namespace Integration{
 
    double Simpson(double (*f)(double), double a,double b,unsigned int n);
    
    double Simpson(double (*f)(double,double),double r, double a,double b,unsigned int n);
    
    double Improper(double (*f)(double), double a,unsigned int n);
 
 
    double Improper(double (*f)(double,double),double r, double a,unsigned int n);
} //namespace Integration
 
} //namespace Pds
#endif