parallel.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_PARALLEL_H
#define THEORETICA_PARALLEL_H
 
#include "./vec.h"
#include "../core/dataset.h"
#include "../core/real_analysis.h"
#include "../complex/complex_analysis.h"
#include "../autodiff/dual_functions.h"
#include "../autodiff/dual2_functions.h"
#include "../autodiff/multidual_functions.h"
 
 
namespace theoretica {
 
 
    namespace parallel {
 
 
        // Unary operations
 
 
        template<typename Function, typename Vector>
        inline Vector map(Function f, const Vector& v) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = f(v[i]);
 
            return res;
        }
 
 
        template<typename Function, typename Vector>
        inline Vector& transform(Function f, Vector& v) {
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                v[i] = f(v[i]);
 
            return v;
        }
 
 
        template<typename Vector>
        inline Vector square(const Vector& v) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::square(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector cube(const Vector& v) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::cube(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector abs(const Vector& v) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::abs(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector pow(const Vector& v, int n) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::pow(v[i], n);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector powf(const Vector& v, real x) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::powf(v[i], x);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector sqrt(const Vector& v) {
 
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::sqrt(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector cbrt(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::cbrt(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector exp(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::exp(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector ln(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::ln(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector log2(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::log2(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector log10(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::log10(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector sin(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::sin(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector cos(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::cos(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector tan(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::tan(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector cot(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::cot(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector asin(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::asin(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector acos(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::acos(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector atan(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::atan(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector sinh(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::sinh(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector cosh(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::cosh(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector tanh(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::tanh(v[i]);
 
            return res;
        }
 
 
        template<typename Vector>
        inline Vector coth(const Vector& v) {
            
            Vector res;
            res.resize(v.size());
 
            #pragma omp parallel for
            for (unsigned int i = 0; i < v.size(); i++)
                res[i] = theoretica::coth(v[i]);
 
            return res;
        }
    }
}
 
#endif