Math.h

Go to the documentation of this file.

/*
 * Copyright (C) 2011 RobotCub Consortium, European Commission FP6 Project IST-004370
 * author:  Arjan Gijsberts
 * email:   arjan.gijsberts@iit.it
 * website: www.robotcub.org
 * Permission is granted to copy, distribute, and/or modify this program
 * under the terms of the GNU General Public License, version 2 or any
 * later version published by the Free Software Foundation.
 *
 * A copy of the license can be found at
 * http://www.robotcub.org/icub/license/gpl.txt
 *
 * 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
 */
 
#ifndef LM_MATH__
#define LM_MATH__
 
#include <gsl/gsl_linalg.h>
 
#include <yarp/sig/Matrix.h>
#include <yarp/sig/Vector.h>
#include <yarp/math/RandScalar.h>
#include <yarp/math/RandnScalar.h>
 
 
namespace iCub {
namespace learningmachine {
namespace math {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/*
 * Rank-1 update of a Cholesky factor
 *
 * Input:
 *   r: upper triangular cholesky factor (ldr x p, typically ldr == p)
 *   x: update vector
 *   z: set of nz column vectors to be updated (ldz x nz, typically ldz == p)
 *   y: nz dimensional vector
 *   rho: nz dimensional vector of norms of residuals
 * Output:
 *   r: updated cholesky factor
 *   z: updated column vectors
 *   rho: updated residual norm
 *   c: cosines of performed givens rotations
 *   s: sines of performed givens rotations
 *
 *
 * Note: Follows LINPACKs' dchud, but with the following differences
 * - accepts transposed Cholesky factor R (non-transposed is faster)
 * - uses CBLAS' drot and drotg for Given's rotations (as in Mattias Seeger's
 *   implementation)
 * - accepts transposed Z (non-transposed is faster)
 * - optional: enforces positive elements on the diagonal of R (as in Mattias
 *   Seeger's implementation, uncomment to enable)
 *
 * Please see the LINPACK User Guide for more detailed information on the
 * update routine and a less terse description of the parameters.
 */
void dchud(double* r, int ldr, int p, double* x, double* z, int ldz, int nz,
           double* y, double* rho, double* c, double* s,
           unsigned char rtrans = 0, unsigned char ztrans = 0);
 
/*
 * GSL type wrapper function for C implementation of dchud.
 */
void gsl_linalg_cholesky_update(gsl_matrix* R, gsl_vector* x, gsl_vector* c, gsl_vector* s,
                                gsl_matrix* Z = NULL, gsl_vector* y = NULL, gsl_vector* rho = NULL,
                                unsigned char rtrans = 0, unsigned char ztrans = 0);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
void cholupdate(yarp::sig::Matrix& R, const yarp::sig::Vector& x, yarp::sig::Vector& c, yarp::sig::Vector& s,
                yarp::sig::Matrix& Z, const yarp::sig::Vector& y, yarp::sig::Vector& rho, bool rtrans = 0, bool ztrans = 0);
 
void cholupdate(yarp::sig::Matrix& R, const yarp::sig::Vector& x, bool rtrans = 0);
 
void cholsolve(const yarp::sig::Matrix& R, const yarp::sig::Matrix& B, yarp::sig::Matrix& X);
 
yarp::sig::Matrix cholsolve(const yarp::sig::Matrix& R, const yarp::sig::Matrix& B);
 
void cholsolve(const yarp::sig::Matrix& R, const yarp::sig::Vector& b, yarp::sig::Vector& x);
 
yarp::sig::Vector cholsolve(const yarp::sig::Matrix& R, const yarp::sig::Vector& b);
 
yarp::sig::Matrix outerprod(const yarp::sig::Vector& v1, const yarp::sig::Vector& v2);
 
yarp::sig::Vector& addvec(yarp::sig::Vector& v, double val);
 
void trsolve(const yarp::sig::Matrix& A, const yarp::sig::Vector& b, yarp::sig::Vector& x, bool transa = false);
 
 
yarp::sig::Vector trsolve(const yarp::sig::Matrix& A, const yarp::sig::Vector& b, bool transa = false);
 
void fillrandom(yarp::sig::Vector& v, yarp::math::RandScalar& prng);
 
void fillrandom(yarp::sig::Matrix& M, yarp::math::RandScalar& prng);
 
void fillrandom(yarp::sig::Vector& v, yarp::math::RandnScalar& prng);
 
void fillrandom(yarp::sig::Matrix& M, yarp::math::RandnScalar& prng);
 
yarp::sig::Vector random(int length, yarp::math::RandScalar& prng);
 
yarp::sig::Matrix random(int rows, int columns, yarp::math::RandScalar& prng);
 
// why do RandScalar and RandnScalar not share a common base class?
yarp::sig::Vector random(int length, yarp::math::RandnScalar& prng);
 
yarp::sig::Matrix random(int rows, int columns, yarp::math::RandnScalar& prng);
 
yarp::sig::Vector& map(yarp::sig::Vector& v, double (op)(double));
 
yarp::sig::Matrix& map(yarp::sig::Matrix& M, double (op)(double));
 
yarp::sig::Vector map(const yarp::sig::Vector& v, double (op)(double));
 
yarp::sig::Matrix map(const yarp::sig::Matrix& M, double (op)(double));
 
yarp::sig::Matrix& cosmat(yarp::sig::Matrix& M);
 
yarp::sig::Matrix& sinmat(yarp::sig::Matrix& M);
 
yarp::sig::Vector& cosvec(yarp::sig::Vector& v);
 
yarp::sig::Vector& sinvec(yarp::sig::Vector& v);
 
yarp::sig::Matrix cosmat(const yarp::sig::Matrix& M);
 
yarp::sig::Matrix sinmat(const yarp::sig::Matrix& M);
 
yarp::sig::Vector cosvec(const yarp::sig::Vector& v);
 
yarp::sig::Vector sinvec(const yarp::sig::Vector& v);
 
} // math
} // learningmachine
} // iCub
 
#endif