algebra.h

Go to the documentation of this file.

#ifndef ALGEBRA_H
#define ALGEBRA_H
 
#include <iostream>
#include <cmath> // sqrt,fabs
#include <algorithm>
 
 
#include "sparseMat.h"
 
#include "algebraCore.h"
#include "iter.h"
 
namespace algebra
{
template <typename T>
T sq(const T x) { return x * x; }
 
template <typename T>
void scaled( const T alpha, std::vector<T> & Y)
    { std::for_each(Y.begin(),Y.end(),[alpha](T &_x){ _x *= alpha; }); }
 
template <typename T>
void p_direct(const std::vector<T> & X,const std::vector<T> & Y, std::vector<T> & Z)
    { std::transform(X.begin(),X.end(),Y.begin(),Z.begin(), std::multiplies<T>() ); }
 
template <typename T>
void add(const std::vector<T> & X, std::vector<T> & Y)
    {
    for (size_t i = 0; i < Y.size(); ++i)
        Y[i] += X[i];
    }
 
template <typename T>
void sub(const std::vector<T> & X, std::vector<T> & Y)
    {
    for (size_t i = 0; i < Y.size(); ++i)
        Y[i] -= X[i];
    }
 
template <typename T>
void scaled_add(const std::vector<T> & X,const T alpha, std::vector<T> & Y)
    {
    for (size_t i = 0; i < Y.size(); ++i)
        Y[i] += alpha * X[i];
    }
 
template <typename T>
void mult(r_sparseMat & A, std::vector<T> const& X, std::vector<T> &Y)
    {
    A.mult(X,Y); // Y = A*X
    }
 
template <typename T>
void applyMask(const std::vector<int>& mask, std::vector<T> & X)
    { std::for_each(mask.begin(),mask.end(),[&X](const int _i){ X[_i] = (T)(0); }); }
 
inline std::ostream & operator<<(std::ostream & flux, r_sparseMat const& m)
    {m.print(flux); return flux;}
 
template <typename T>
bool check(std::vector<T> &v)
    { return std::none_of(v.begin(),v.end(), [](T x){ return std::isnan(x);} );  }
} // end namespace algebra
 
#endif