ArrayAlgorithms.h

Go to the documentation of this file.

/* Copyright 2020 Kristofer Björnson
 *
 * 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.
 */

#ifndef COM_DAFER45_TBTK_MATH_ARRAY_ALGORITHMS
#define COM_DAFER45_TBTK_MATH_ARRAY_ALGORITHMS

#include "TBTK/Array.h"

#include <cmath>

namespace TBTK{
namespace Math{

template<typename DataType>
class ArrayAlgorithms{
public:
    static Array<DataType> sin(const Array<DataType> &array);

    static Array<DataType> cos(const Array<DataType> &array);

    static Array<DataType> tan(const Array<DataType> &array);

    static Array<DataType> asin(const Array<DataType> &array);

    static Array<DataType> acos(const Array<DataType> &array);

    static Array<DataType> atan(const Array<DataType> &array);

    static Array<DataType> sinh(const Array<DataType> &array);

    static Array<DataType> cosh(const Array<DataType> &array);

    static Array<DataType> tanh(const Array<DataType> &array);

    static Array<DataType> asinh(const Array<DataType> &array);

    static Array<DataType> acosh(const Array<DataType> &array);

    static Array<DataType> atanh(const Array<DataType> &array);

    static Array<DataType> log(const Array<DataType> &array);

    static Array<DataType> log2(const Array<DataType> &array);

    static Array<DataType> log10(const Array<DataType> &array);

    static Array<DataType> pow(
        const Array<DataType> &array,
        double exponent
    );

    static Array<DataType> exp(const Array<DataType> &array);

    template<typename T = DataType>
    static typename std::enable_if<
        !std::is_same<T, std::complex<double>>::value,
        Array<DataType>
    >::type abs(const Array<DataType> &array);

    template<typename T = DataType>
    static typename std::enable_if<
        std::is_same<T, std::complex<double>>::value,
        Array<double>
    >::type abs(const Array<DataType> &array);

    template<typename T = DataType>
    static typename std::enable_if<
        std::is_same<T, std::complex<double>>::value,
        Array<double>
    >::type arg(const Array<std::complex<double>> &array);

    template<typename T = DataType>
    static typename std::enable_if<
        std::is_same<T, std::complex<double>>::value,
        Array<double>
    >::type real(const Array<std::complex<double>> &array);

    template<typename T = DataType>
    static typename std::enable_if<
        std::is_same<T, std::complex<double>>::value,
        Array<double>
    >::type imag(const Array<std::complex<double>> &array);

    template<typename T = DataType>
    static typename std::enable_if<
        std::is_same<T, std::complex<double>>::value,
        Array<DataType>
    >::type conj(const Array<DataType> &array);

    static Array<DataType> sqrt(const Array<DataType> &array);

    static DataType max(const Array<DataType> &array);

    static DataType min(const Array<DataType> &array);
private:
};

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::sin(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::sin(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::cos(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::cos(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::tan(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::tan(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::asin(
    const Array<DataType> &array
){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::asin(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::acos(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::acos(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::atan(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::atan(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::sinh(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::sinh(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::cosh(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::cosh(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::tanh(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::tanh(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::asinh(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::asinh(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::acosh(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::acosh(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::atanh(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::atanh(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::log(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::log(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::log2(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::log2(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::log10(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::log10(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::pow(
    const Array<DataType> &array,
    double exponent
){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::pow(arrayData[n], exponent);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::exp(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::exp(arrayData[n]);

    return result;
}

template<typename DataType>
template<typename T>
typename std::enable_if<
    !std::is_same<T, std::complex<double>>::value,
    Array<DataType>
>::type ArrayAlgorithms<DataType>::abs(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::abs(arrayData[n]);

    return result;
}

template<typename DataType>
template<typename T>
typename std::enable_if<
    std::is_same<T, std::complex<double>>::value,
    Array<double>
>::type ArrayAlgorithms<DataType>::abs(const Array<DataType> &array){
    Array<double> result = Array<double>::create(array.getRanges());
    CArray<double> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::abs(arrayData[n]);

    return result;
}

template<typename DataType>
template<typename T>
typename std::enable_if<
    std::is_same<T, std::complex<double>>::value,
    Array<double>
>::type ArrayAlgorithms<DataType>::arg(const Array<std::complex<double>> &array){
    Array<double> result = Array<double>::create(array.getRanges());
    CArray<double> &resultData = result.getData();
    const CArray<std::complex<double>> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::arg(arrayData[n]);

    return result;
}

template<typename DataType>
template<typename T>
typename std::enable_if<
    std::is_same<T, std::complex<double>>::value,
    Array<double>
>::type ArrayAlgorithms<DataType>::real(const Array<std::complex<double>> &array){
    Array<double> result = Array<double>::create(array.getRanges());
    CArray<double> &resultData = result.getData();
    const CArray<std::complex<double>> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::real(arrayData[n]);

    return result;
}

template<typename DataType>
template<typename T>
typename std::enable_if<
    std::is_same<T, std::complex<double>>::value,
    Array<double>
>::type ArrayAlgorithms<DataType>::imag(const Array<std::complex<double>> &array){
    Array<double> result = Array<double>::create(array.getRanges());
    CArray<double> &resultData = result.getData();
    const CArray<std::complex<double>> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::imag(arrayData[n]);

    return result;
}

template<typename DataType>
template<typename T>
typename std::enable_if<
    std::is_same<T, std::complex<double>>::value,
    Array<DataType>
>::type ArrayAlgorithms<DataType>::conj(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::conj(arrayData[n]);

    return result;
}

template<typename DataType>
Array<DataType> ArrayAlgorithms<DataType>::sqrt(const Array<DataType> &array){
    Array<DataType> result = Array<DataType>::create(array.getRanges());
    CArray<DataType> &resultData = result.getData();
    const CArray<DataType> &arrayData = array.getData();

    for(unsigned int n = 0; n < array.getSize(); n++)
        resultData[n] = std::sqrt(arrayData[n]);

    return result;
}

template<typename DataType>
DataType ArrayAlgorithms<DataType>::max(const Array<DataType> &array){
    const CArray<DataType> &arrayData = array.getData();
    DataType maximum = arrayData[0];
    for(unsigned int n = 1; n < array.getSize(); n++)
        if(maximum < arrayData[n])
            maximum = arrayData[n];

    return maximum;
}

template<typename DataType>
DataType ArrayAlgorithms<DataType>::min(const Array<DataType> &array){
    const CArray<DataType> &arrayData = array.getData();
    DataType minimum = arrayData[0];
    for(unsigned int n = 1; n < array.getSize(); n++)
        if(minimum > arrayData[n])
            minimum = arrayData[n];

    return minimum;
}

template<typename DataType>
Array<DataType> sin(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::sin(array);
}

template<typename DataType>
Array<DataType> cos(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::cos(array);
}

template<typename DataType>
Array<DataType> tan(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::tan(array);
}

template<typename DataType>
Array<DataType> asin(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::asin(array);
}

template<typename DataType>
Array<DataType> acos(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::acos(array);
}

template<typename DataType>
Array<DataType> atan(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::atan(array);
}

template<typename DataType>
Array<DataType> sinh(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::sinh(array);
}

template<typename DataType>
Array<DataType> cosh(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::cosh(array);
}

template<typename DataType>
Array<DataType> tanh(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::tanh(array);
}

template<typename DataType>
Array<DataType> asinh(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::asinh(array);
}

template<typename DataType>
Array<DataType> acosh(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::acosh(array);
}

template<typename DataType>
Array<DataType> atanh(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::atanh(array);
}

template<typename DataType>
Array<DataType> log(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::log(array);
}

template<typename DataType>
Array<DataType> log2(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::log2(array);
}

template<typename DataType>
Array<DataType> log10(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::log10(array);
}

template<typename DataType>
Array<DataType> pow(const Array<DataType> &array, double exponent){
    return ArrayAlgorithms<DataType>::pow(array, exponent);
}

template<typename DataType>
Array<DataType> exp(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::exp(array);
}

template<typename DataType>
typename std::enable_if<
    !std::is_same<DataType, std::complex<double>>::value,
    Array<DataType>
>::type abs(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::abs(array);
}

template<typename DataType>
typename std::enable_if<
    std::is_same<DataType, std::complex<double>>::value,
    Array<double>
>::type abs(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::abs(array);
}

inline Array<double> arg(const Array<std::complex<double>> &array){
    return ArrayAlgorithms<std::complex<double>>::arg(array);
}

inline Array<double> real(const Array<std::complex<double>> &array){
    return ArrayAlgorithms<std::complex<double>>::real(array);
}

inline Array<double> imag(const Array<std::complex<double>> &array){
    return ArrayAlgorithms<std::complex<double>>::imag(array);
}

inline Array<std::complex<double>> conj(const Array<std::complex<double>> &array){
    return ArrayAlgorithms<std::complex<double>>::conj(array);
}

template<typename DataType>
Array<DataType> sqrt(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::sqrt(array);
}

template<typename DataType>
DataType max(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::max(array);
}

template<typename DataType>
DataType min(const Array<DataType> &array){
    return ArrayAlgorithms<DataType>::min(array);
}

}; //End of namespace Math
}; //End of namespace TBTK

#endif