AlgebraicVector_t.h

Go to the documentation of this file.

/******************************************************************************
*                                                                             *
* DIFFERENTIAL ALGEBRA CORE ENGINE                                            *
*                                                                             *
*******************************************************************************
*                                                                             *
* Copyright 2016 Politecnico di Milano (2014 Dinamica Srl)                    *
* Licensed under the Apache License, Version 2.0 (the "License");             *
* you may not use this file except in compliance with the License.            *
* You may obtain a copy of the License at                                     *
*                                                                             *
*    http://www.apache.org/licenses/LICENSE-2.0                               *
*                                                                             *
* Unless required by applicable law or agreed to in writing, software         *
* distributed under the License is distributed on an "AS IS" BASIS,           *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    *
* See the License for the specific language governing permissions and         *
* limitations under the License.                                              *
*                                                                             *
*******************************************************************************/

/*
 * AlgebraicVector_t.h
 *
 *  Created on: Sep. 10, 2014
 *      Author: Dinamica Srl
 */

#ifndef DINAMICA_ALGEBRAICVECTOR_T_H_
#define DINAMICA_ALGEBRAICVECTOR_T_H_

// C++ stdlib classes used only internally in this implementation
#include <cmath>
#include <sstream>
#include <stdexcept>
#include <string>

// DACE classes
#include "dace/PromotionTrait.h"
#include "dace/MathExtension.h"
#include "dace/compiledDA.h"
#include "dace/AlgebraicVector.h"
#ifdef WITH_ALGEBRAICMATRIX
#include "dace/AlgebraicMatrix.h"
#include "dace/AlgebraicMatrix_t.h"
#endif /* WITH_ALGEBRAICMATRIX */

namespace DACE{

/***********************************************************************************
*     Constructors
************************************************************************************/
template<typename T> AlgebraicVector<T>::AlgebraicVector() : std::vector<T>(){
}

template<typename T> AlgebraicVector<T>::AlgebraicVector(size_t size) : std::vector<T>(size){
}

template<typename T> AlgebraicVector<T>::AlgebraicVector(size_t size, const T &d) : std::vector<T>(size, d){
}

template<typename T> AlgebraicVector<T>::AlgebraicVector(const std::vector<T> &v) : std::vector<T>(v){
}

template<typename T> AlgebraicVector<T>::AlgebraicVector(std::initializer_list<T> l) : std::vector<T>(l){
}

template<typename T> AlgebraicVector<T>::AlgebraicVector(const std::vector<T> &v, size_t first, size_t last) : std::vector<T>(v.begin()+first, v.begin()+last+1){
    // Notice that the range in the std::vector constructor above includes all
    // elements between first and last, including the first excluding the last.
    // Hence the +1.
}

/***********************************************************************************
*     Coefficient access routines
************************************************************************************/
template<typename T> AlgebraicVector<double> AlgebraicVector<T>::cons() const{
    using DACE::cons;

    const size_t size = this->size();
    AlgebraicVector<double> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = cons((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::extract(const size_t first, const size_t last) const
{
    if(first>=this->size() || last>=this->size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::take: Indices out of bounds.");

    return AlgebraicVector<T>(*this, first, last);
}

template<typename T> template<typename V> AlgebraicVector<typename PromotionTrait< T, V >::returnType> AlgebraicVector<T>::concat(const std::vector<V> &obj) const{
    const size_t size1 = this->size();
    const size_t size2 = obj.size();
    AlgebraicVector<typename PromotionTrait< T, V >::returnType> res(size1+size2);

    for(size_t i=0; i<size1; i++)
        res[i] = (*this)[i];
    for(size_t i=0; i<size2; i++)
        res[i+size1] = obj[i];

    return res;
}

/***********************************************************************************
*     Algebraic operations
************************************************************************************/
template<typename T> AlgebraicVector<T> AlgebraicVector<T>::operator-() const{
    return -1.0*(*this);
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator+=(const AlgebraicVector<U> &obj){
    const size_t size = this->size();
    if(size != obj.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator+=: Vectors must have the same length.");

    for(size_t i=0; i<size; i++){
        (*this)[i] += obj[i];}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator+=(const U &obj){
    const size_t size = this->size();
    for(size_t i=0; i<size; i++){
        (*this)[i] += obj;}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator-=(const AlgebraicVector<U> &obj){
    const size_t size = this->size();
    if(size != obj.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator-=: Vectors must have the same length.");

    for(size_t i=0; i<size; i++){
        (*this)[i] -= obj[i];}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator-=(const U &obj){
    const size_t size = this->size();
    for(size_t i=0; i<size; i++){
        (*this)[i] -= obj;}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator*=(const AlgebraicVector<U> &obj){
    const size_t size = this->size();
    if(size != obj.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator*=: Vectors must have the same length.");

    for(size_t i=0; i<size; i++){
        (*this)[i] *= obj[i];}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator*=(const U &obj){
    const size_t size = this->size();
    for(size_t i=0; i<size; i++){
        (*this)[i] *= obj;}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator/=(const AlgebraicVector<U> &obj){
    const size_t size = this->size();
    if(size != obj.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator/=: Vectors must have the same length.");

    for(size_t i=0; i<size; i++){
        (*this)[i] /= obj[i];}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator/=(const U &obj){
    const size_t size = this->size();
    for(size_t i=0; i<size; i++){
        (*this)[i] /= obj;}
    return *this;
}

template<typename T> template<typename U> AlgebraicVector<T>& AlgebraicVector<T>::operator<<(const std::vector<U> &obj){
    const size_t size = obj.size();
    for(size_t i=0; i<size; i++){
        (*this).push_back((T)obj[i]);}
    return *this;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator+(const AlgebraicVector<U> &obj1, const AlgebraicVector<V> &obj2){
    if(obj1.size() != obj2.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator+: Vectors must have the same length.");

    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] + obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator+(const AlgebraicVector<U> &obj1, const V &obj2){
    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] + obj2;}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator+(const U &obj1, const AlgebraicVector<V> &obj2){
    const size_t size = obj2.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1 + obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator-(const AlgebraicVector<U> &obj1, const AlgebraicVector<V> &obj2){
    if(obj1.size() != obj2.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator-: Vectors must have the same length.");

    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] - obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator-(const AlgebraicVector<U> &obj1, const V &obj2){
    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] - obj2;}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator-(const U &obj1, const AlgebraicVector<V> &obj2){
    const size_t size = obj2.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1 - obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator*(const AlgebraicVector<U> &obj1, const AlgebraicVector<V> &obj2){
    if(obj1.size() != obj2.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator*: Vectors must have the same length.");

    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] * obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator*(const AlgebraicVector<U> &obj1, const V &obj2){
    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] * obj2;}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator*(const U &obj1, const AlgebraicVector<V> &obj2){
    const size_t size = obj2.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1 * obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator/(const AlgebraicVector<U> &obj1, const AlgebraicVector<V> &obj2){
    if(obj1.size() != obj2.size())
        throw std::runtime_error("DACE::AlgebraicVector<T>::operator/: Vectors must have the same length.");

    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] / obj2[i];}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator/(const AlgebraicVector<U> &obj1, const V &obj2){
    const size_t size = obj1.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1[i] / obj2;}
    return temp;
}

template<typename U,typename V> AlgebraicVector<typename PromotionTrait< U, V >::returnType> operator/(const U &obj1, const AlgebraicVector<V> &obj2){
    const size_t size = obj2.size();
    AlgebraicVector<typename PromotionTrait< U, V >::returnType> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = obj1 / obj2[i];}
    return temp;
}

template<typename T> template<typename V> typename PromotionTrait<T,V>::returnType AlgebraicVector<T>::dot(const AlgebraicVector<V> &obj) const{
    const size_t size = this->size();
    if(size != obj.size())
          throw std::runtime_error("DACE::AlgebraicVector<T>::dot(): Vectors must have the same length.");

    typename PromotionTrait<T,V>::returnType temp = 0;
    for(size_t i=0; i<size; i++){
        temp += (*this)[i] * obj[i];}

    return temp;
}

template<typename T> template<typename V> AlgebraicVector<typename PromotionTrait<T,V>::returnType> AlgebraicVector<T>::cross(const AlgebraicVector<V> &obj) const{
    if((this->size() != 3) || (obj.size() != 3))
        throw std::runtime_error("DACE::AlgebraicVector<T>::cross(): Inputs must be 3 element AlgebraicVectors.");

    AlgebraicVector<typename PromotionTrait<T,V>::returnType> temp(3);

    temp[0] = ((*this)[1] * obj[2]) - ((*this)[2] * obj[1]);
    temp[1] = ((*this)[2] * obj[0]) - ((*this)[0] * obj[2]);
    temp[2] = ((*this)[0] * obj[1]) - ((*this)[1] * obj[0]);

    return temp;
}

/***********************************************************************************
*     Math routines
************************************************************************************/
template<typename T> AlgebraicVector<T> AlgebraicVector<T>::pow(const int p) const{
    using std::pow;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = pow((*this)[i], p);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::sqrt() const{
    using std::sqrt;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = sqrt((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::exp() const{
    using std::exp;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = exp((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::log() const{
    using std::log;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = log((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::sin() const{
    using std::sin;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = sin((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::cos() const{
    using std::cos;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = cos((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::tan() const{
    using std::tan;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = tan((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::asin() const{
    using std::asin;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = asin((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::acos() const{
    using std::acos;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = acos((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::atan() const{
    using std::atan;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = atan((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::atan2(const AlgebraicVector<T> &obj) const{
    using std::atan2;

    const size_t size = this->size();
    if(obj.size() != size)
        throw std::runtime_error("DACE::AlgebraicVector<T>::atan2(): Vectors must have the same length.");

    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = atan2((*this)[i], obj[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::sinh() const{
    using std::sinh;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = sinh((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::cosh() const{
    using std::cosh;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = cosh((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::tanh() const{
    using std::tanh;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = tanh((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::logb(const double b) const{
    using DACE::logb;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = logb((*this)[i], b);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::isrt() const{
    using DACE::isrt;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = isrt((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::sqr() const{
    using DACE::sqr;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = sqr((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::minv() const{
    using DACE::minv;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = minv((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::root(const int p) const{
    using DACE::root;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = root((*this)[i],p);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::asinh() const{
    using DACE::asinh;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = asinh((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::acosh() const{
    using DACE::acosh;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = acosh((*this)[i]);}

    return temp;
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::atanh() const{
    using DACE::atanh;

    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    for(size_t i=0; i<size; i++){
        temp[i] = atanh((*this)[i]);}

    return temp;
}

/***********************************************************************************
*    Vector norm routines
************************************************************************************/
template<typename T> T AlgebraicVector<T>::vnorm() const{
    using std::sqrt; using DACE::sqr;      // Implementational note: these using statements are very subtle and absolutely needed.
                                            // They force the compiler to perform argument dependent lookup (ADL) which then finds
                                            // the correct root() and pow() functions even if they are not in DACE:: or std::!
    const size_t size = this->size();
    T norm = 0.0;
    for(size_t i=0; i<size; i++){
        norm = norm + sqr((*this)[i]);}

    return sqrt(norm);
}

template<typename T> AlgebraicVector<T> AlgebraicVector<T>::normalize() const{
    const size_t size = this->size();
    AlgebraicVector<T> temp(size);
    T norm = 1.0/this->vnorm();

    for(size_t i=0; i<size; i++){
        temp[i] = (*this)[i]*norm;}

    return temp;
}

/***********************************************************************************
*     Polynomial evaluation routines
************************************************************************************/
template<> template<typename V> V AlgebraicVector<DA>::eval(const V &args) const{
    return compiledDA(*this).eval(args);
}

template<> template<typename U> AlgebraicVector<U> AlgebraicVector<DA>::eval(const std::initializer_list<U> l) const{
    return compiledDA(*this).eval<U>(l);
}

template<> template<typename U> AlgebraicVector<U> AlgebraicVector<DA>::evalScalar(const U &arg) const{
    return compiledDA(*this).evalScalar(arg);
}

/***********************************************************************************
*     Input/Output routines
************************************************************************************/
template<typename U> std::ostream& operator<<(std::ostream &out, const AlgebraicVector<U> &obj){
    const size_t size = obj.size();

    out << "[[[ " << size << " vector" << std::endl;
    for(size_t i=0; i<size;i++){
        out << obj[i] << std::endl;}
    out << "]]]" << std::endl;

    return out;
}

template<typename U> std::istream& operator>>(std::istream &in, AlgebraicVector<U> &obj){
    std::string init_line;
    size_t vec_size;

    // try to read the first line
    getline(in, init_line);
    if(in.good()){
        // retrieve the size of the vector to be read
        std::size_t found = init_line.find_first_of(' ');
        std::string size_str(init_line,4,found-4);
        if(!(std::istringstream(size_str) >> vec_size)) vec_size = 0;

        // resize the object to meet the size of the vector to be read
        obj.resize(vec_size);

        // fill the AlgebraicVector
        for (size_t i = 0; in.good() && (i < vec_size); i++) {
            in >> obj[i];

            // check the next character
            if (in.peek() == '\n')       // the previous operator>> does not consume the \n character when an AlgebraicVector<T> (with T != DA) is considered
                in.ignore();            // ignore the next character
        }
        // skip the line at the end of a AlgebraicVector (containing ]]])
        getline(in, init_line);
    }else{
        obj.resize(0);}

    return in;
}

template<typename T> std::string AlgebraicVector<T>::toString() const{
    std::ostringstream strs;
    strs << *this << std::endl;

    return strs.str();
}

/***********************************************************************************
*     Non-member functions
************************************************************************************/
template<typename T> AlgebraicVector<double> cons(const AlgebraicVector<T> &obj){
    return obj.cons();
}

template<typename T> AlgebraicVector<T> pow(const AlgebraicVector<T> &obj, const int p){
    return obj.pow(p);
}

template<typename T> AlgebraicVector<T> root(const AlgebraicVector<T> &obj, const int p){
    return obj.root(p);
}

template<typename T> AlgebraicVector<T> minv(const AlgebraicVector<T> &obj){
    return obj.minv();
}

template<typename T> AlgebraicVector<T> sqr(const AlgebraicVector<T> &obj){
    return obj.sqr();
}

template<typename T> AlgebraicVector<T> sqrt(const AlgebraicVector<T> &obj){
    return obj.sqrt();
}

template<typename T> AlgebraicVector<T> isrt(const AlgebraicVector<T> &obj){
    return obj.isrt();
}

template<typename T> AlgebraicVector<T> exp(const AlgebraicVector<T> &obj){
    return obj.exp();
}

template<typename T> AlgebraicVector<T> log(const AlgebraicVector<T> &obj){
    return obj.log();
}

template<typename T> AlgebraicVector<T> logb(const AlgebraicVector<T> &obj, const double b){
    return obj.logb(b);
}

template<typename T> AlgebraicVector<T> sin(const AlgebraicVector<T> &obj){
    return obj.sin();
}

template<typename T> AlgebraicVector<T> cos(const AlgebraicVector<T> &obj){
    return obj.cos();
}

template<typename T> AlgebraicVector<T> tan(const AlgebraicVector<T> &obj){
    return obj.tan();
}

template<typename T> AlgebraicVector<T> asin(const AlgebraicVector<T> &obj){
    return obj.asin();
}

template<typename T> AlgebraicVector<T> acos(const AlgebraicVector<T> &obj){
    return obj.acos();
}

template<typename T> AlgebraicVector<T> atan(const AlgebraicVector<T> &obj){
    return obj.atan();
}

template<typename T> AlgebraicVector<T> atan2(const AlgebraicVector<T> &obj1, const AlgebraicVector<T> &obj2){
    return obj1.atan(obj2);
}

template<typename T> AlgebraicVector<T> sinh(const AlgebraicVector<T> &obj){
    return obj.sinh();
}

template<typename T> AlgebraicVector<T> cosh(const AlgebraicVector<T> &obj){
    return obj.cosh();
}

template<typename T> AlgebraicVector<T> tanh(const AlgebraicVector<T> &obj){
    return obj.tanh();
}

template<typename T> AlgebraicVector<T> asinh(const AlgebraicVector<T> &obj){
    return obj.asinh();
}

template<typename T> AlgebraicVector<T> acosh(const AlgebraicVector<T> &obj){
    return obj.acosh();
}

template<typename T> AlgebraicVector<T> atanh(const AlgebraicVector<T> &obj){
    return obj.atanh();
}

template<typename U, typename V> typename PromotionTrait<U,V>::returnType dot(const AlgebraicVector<U> &obj1, const AlgebraicVector<V> &obj2){
    return obj1.dot(obj2);
}

template<typename U, typename V> AlgebraicVector<typename PromotionTrait<U,V>::returnType> cross(const AlgebraicVector<U> &obj1, const AlgebraicVector<V> &obj2){
    return obj1.cross(obj2);
}

template<typename T> T vnorm(const AlgebraicVector<T> &obj){
    return obj.vnorm();
}

template<typename T> AlgebraicVector<T> normalize(const AlgebraicVector<T> &obj){
    return obj.normalize();
}

template<typename V> V eval(const AlgebraicVector<DA> &obj, const V &args){
    return obj.eval(args);
}

template<typename T> AlgebraicVector<T> eval(const AlgebraicVector<DA> &obj, const std::initializer_list<T> l){
    return obj.eval<T>(l);
}

template<typename U> AlgebraicVector<U> evalScalar(const AlgebraicVector<DA> &obj, const U &arg){
    return obj.evalScalar(arg);
}

}
#endif /* DINAMICA_ALGEBRAICVECTOR_T_H_ */