primitive_functions.h

Go to the documentation of this file.

/***
 * Copyright (c) 2005, SkeTo Project
 * All rights reserved.
 */
#ifndef __PRIMITIVE_FUNCTIONS_H__
#define __PRIMITIVE_FUNCTIONS_H__

#include "matrix.h"
#include <ctime>
#include <cstdlib>

namespace primitive_functions {

template<typename A>
class Id : public skeleton::unary_function< A, A >{
public:
    void operator()(const A &a, A *r) const {
        *r = a;
    }
};

template<typename A, typename B>
class Fst : public skeleton::binary_function< A, A, B >{
public:
    void operator()(const A &a, const B &, A *r) const {
        *r = a;
    }
};
template<typename A, typename B>
class Snd : public skeleton::binary_function< A, B, B >{
public:
    void operator()(const A &, const B &b, B *r) const {
        *r = b;
    }
};

template<typename A>
class Singleton : public skeleton::unary_function< A, matrix <A> >{
public:
    void operator()(const A &a, matrix <A> *mat) const {
        mat->singleton(a);
    }
};


template <typename A>
class The {
public:
    void operator()(const matrix <A> &mat, A *r) const{
        *r = mat.at(0,0);
    }
};

template<typename A>
class Singleton2 {
public:
    void operator()(const A &a, matrix <matrix <A> > *mat) const {
        matrix <A> singl;
        singl.singleton(a);
        mat->singleton(singl);
    }
};

template <typename A>
class Abv : public skeleton::binary_function<matrix <A>, matrix <A>, matrix <A> >{
public:
    void operator()(const matrix <A> &a, const matrix <A> &b, matrix <A> *mat) const {
        m_skeletons::abv(&a, &b, mat);
    }
};

template <typename A>
class Bsd  : public skeleton::binary_function<matrix <A>, matrix <A>, matrix <A> >{
public:
    void operator()(const matrix <A> &a, const matrix <A> &b, matrix <A> *mat) const {
        m_skeletons::bsd(&a, &b, mat);
    }
};


template <typename A>
class Zipwbsd {
public:
    void operator()(const matrix <matrix <A> >&a, const matrix <matrix <A> > &b, matrix <matrix <A> > *mat) const {
        m_skeletons::zipwith(Bsd<A>(), &a, &b, mat);
    }
};

template <typename A>
class Zipwabv {
public:
    void operator()(const matrix <matrix <A> > &a, const matrix <matrix <A> > &b, matrix <matrix <A> > *mat) const {
        m_skeletons::zipwith(Abv<A>(), &a, &b, mat);
    }
};

    
template <typename A>
class Tr : public skeleton::unary_function<A , A >{
public:
    void operator()(const A &a, A *r) const {
        *r = a;
        r->tr();
    }
};

template <typename A>
class Left : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &a, const A &, A *r) const {
        *r = a;
    }
};
template <typename A>
class Right : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &, const A &b, A*r) const{
        *r = b;
    }
};

template<typename A>
class SquareI {
public:
    void operator()(A *r) const { 
        *r = *r * *r;
    }
};

template<typename A>
class Square : public skeleton::unary_function<A , A >{
public:
    void operator()(const A&a, A *r) const { 
        *r = a * a;
    }
};

template<typename A>
class Add : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = i + j;
    }
};

template<typename A>
class Sub : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = i - j;
    }
};

template<typename A>
class Mul : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = i * j;
    }
};

template<typename A>
class Div : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = i / j;
    }
};

template<typename A>
class Mod : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = i % j;
    }
};

template<typename A>
class Max : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = (i >= j) ? i : j;
    }
};

template<typename A>
class Min : public skeleton::binary_function< A, A, A > {
public:
    void operator()(const A &i, const A &j, A *r) const {
        *r = (i <= j) ? i : j;
    }
};


template<typename A>
class GenZero {
public:
    void operator()(int , int , A *r) const {
        *r = 0;
    }
};

template<typename A>
class GenAdd {
public:
    void operator()(int i, int j, A *r) const {
        *r = i + j;
    }
};

template<typename A>
class GenSub {
public:
    void operator()(int i, int j, A *r) const {
        *r = i - j;
    }
};

template<typename A>
class GenMul {
public:
    void operator()(int i, int j, A *r) const {
        *r = i * j;
    }
};

class GenRand1 {
public:
    GenRand1(){
        srand((unsigned int)time(NULL));
    }
    void operator()(int i, int j, double *r) const {
        i = j = 0;
        *r = rand()/(double)RAND_MAX;
    }
};
class GenRandN {
    int n;
public:
    GenRandN(int nn){
        n = nn;
        srand((unsigned int)time(NULL));
    }
    void operator()(int i, int j, int *r) const {
        i = j = 0;
        *r = (int)((rand()/(double)RAND_MAX)*n);
    }
};


template <typename A>
class DivBy : public skeleton::unary_function < A, A >{
    A d;
public:
    DivBy(A dd){
        d = dd;
    }
    void operator()(A i, A *r) const {
        *r = i / d;
    }
};
    
}
#endif // __PRIMITIVE_FUNCTIONS_H__

---