VectorNd.h

Go to the documentation of this file.

/* Copyright 2017 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_VECTOR_ND
#define COM_DAFER45_TBTK_VECTOR_ND

#include "TBTK/CArray.h"
#include "TBTK/TBTKMacros.h"

#include <cmath>
#include <initializer_list>
#include <ostream>
#include <vector>

namespace TBTK{

class VectorNd{
public:
    VectorNd();

    VectorNd(unsigned int size);

    VectorNd(std::initializer_list<double> components);

    VectorNd(const std::vector<double> &components);

    double& operator[](unsigned int n);

    const double& operator[](unsigned int n) const;

    const VectorNd operator+(const VectorNd &rhs) const;

    const VectorNd operator-(const VectorNd &rhs) const;

    const VectorNd operator-() const;

    const VectorNd operator*(double rhs) const;

    friend const VectorNd operator*(double lhs, const VectorNd &rhs);

    const VectorNd operator/(double rhs) const;

    const VectorNd unit() const;

    const VectorNd parallel(const VectorNd &v) const;

    double norm() const;

    static double dotProduct(const VectorNd &lhs, const VectorNd &rhs);

    const std::vector<double> getStdVector() const;

    unsigned int getSize() const;

    friend std::ostream& operator<<(std::ostream &stream, const VectorNd &v);
private:
    CArray<double> data;
};

inline double& VectorNd::operator[](unsigned int n){
    return data[n];
}

inline const double& VectorNd::operator[](unsigned int n) const{
    return data[n];
}

inline const VectorNd VectorNd::operator+(const VectorNd &rhs) const{
    TBTKAssert(
        data.getSize() == rhs.data.getSize(),
        "VectorNd::operator+()",
        "Incompatible dimensions. Left hand side has "
        << data.getSize() << " components, while the right hand side"
        << " has " << rhs.getSize() << " components.",
        ""
    );

    VectorNd result(data.getSize());
    for(unsigned int n = 0; n < data.getSize(); n++)
        result.data[n] = data[n] + rhs.data[n];

    return result;
}

inline const VectorNd VectorNd::operator-(const VectorNd &rhs) const{
    TBTKAssert(
        data.getSize() == rhs.data.getSize(),
        "VectorNd::operator-()",
        "Incompatible dimensions. Left hand side has "
        << data.getSize() << " components, while the right hand side"
        << " has " << rhs.data.getSize() << " components.",
        ""
    );

    VectorNd result(data.getSize());
    for(unsigned int n = 0; n < data.getSize(); n++)
        result.data[n] = data[n] - rhs.data[n];

    return result;
}

inline const VectorNd VectorNd::operator-() const{
    VectorNd result(data.getSize());
    for(unsigned int n = 0; n < data.getSize(); n++)
        result.data[n] = -data[n];

    return result;
}

inline const VectorNd VectorNd::operator*(double rhs) const{
    VectorNd result(data.getSize());
    for(unsigned int n = 0; n < data.getSize(); n++)
        result.data[n] = data[n]*rhs;

    return result;
}

inline const VectorNd operator*(double lhs, const VectorNd &rhs){
    VectorNd result(rhs.data.getSize());
    for(unsigned int n = 0; n < rhs.data.getSize(); n++)
        result.data[n] = lhs*rhs.data[n];

    return result;
}

inline const VectorNd VectorNd::operator/(double rhs) const{
    VectorNd result(data.getSize());
    for(unsigned int n = 0; n < data.getSize(); n++)
        result.data[n] = data[n]/rhs;

    return result;
}

inline const VectorNd VectorNd::unit() const{
    return (*this)/norm();
}

inline const VectorNd VectorNd::parallel(const VectorNd &v) const{
    TBTKAssert(
        data.getSize() == v.data.getSize(),
        "VectorNd::parallel()",
        "Incompatible dimensions.",
        ""
    );

    return dotProduct(*this, v.unit())*v.unit();
}

inline double VectorNd::norm() const{
    return sqrt(dotProduct(*this, *this));
}

inline double VectorNd::dotProduct(const VectorNd &lhs, const VectorNd &rhs){
    TBTKAssert(
        lhs.data.getSize() == rhs.data.getSize(),
        "VectorNd::dotProduct()",
        "Incompatible dimensions. Left hand side has "
        << lhs.data.getSize() << " components, while the right hand"
        << " side has " << rhs.data.getSize() << " components.",
        ""
    );

    double dp = 0;
    for(unsigned int n = 0; n < lhs.data.getSize(); n++)
        dp += lhs.data[n]*rhs.data[n];

    return dp;
}

inline const std::vector<double> VectorNd::getStdVector() const{
    std::vector<double> result;
    for(unsigned int n = 0; n < data.getSize(); n++)
        result.push_back(data[n]);

    return result;
}

inline unsigned int VectorNd::getSize() const{
    return data.getSize();
}

inline std::ostream& operator<<(std::ostream &stream, const VectorNd &v){
    stream << "(";
    for(unsigned int n = 0; n < v.data.getSize(); n++){
        if(n != 0)
            stream << ", ";
        stream << v.data[n];
    }

    return stream;
}

};  //End namespace TBTK

#endif