Vector3d.h

Go to the documentation of this file.

/* Copyright 2016 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_3D
#define COM_DAFER45_TBTK_VECTOR_3D

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

namespace TBTK{

class Vector3d{
public:
    double x;

    double y;

    double z;

    Vector3d();

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

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

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

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

    const Vector3d operator-() const;

    const Vector3d operator*(const Vector3d &rhs) const;

    const Vector3d operator*(double rhs) const;

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

    const Vector3d operator/(double rhs) const;

    const Vector3d unit() const;

    const Vector3d perpendicular(const Vector3d &v) const;

    const Vector3d parallel(const Vector3d &v) const;

    double norm() const;

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

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

    friend std::ostream& operator<<(std::ostream &stream, const Vector3d &v);
};

inline const Vector3d Vector3d::operator+(const Vector3d &rhs) const{
    Vector3d result;

    result.x = x + rhs.x;
    result.y = y + rhs.y;
    result.z = z + rhs.z;

    return result;
}

inline const Vector3d Vector3d::operator-(const Vector3d &rhs) const{
    Vector3d result;

    result.x = x - rhs.x;
    result.y = y - rhs.y;
    result.z = z - rhs.z;

    return result;
}

inline const Vector3d Vector3d::operator-() const{
    Vector3d result;

    result.x = -x;
    result.y = -y;
    result.z = -z;

    return result;
}

inline const Vector3d Vector3d::operator*(const Vector3d &rhs) const{
    Vector3d result;

    result.x = y*rhs.z - z*rhs.y;
    result.y = z*rhs.x - x*rhs.z;
    result.z = x*rhs.y - y*rhs.x;

    return result;
}

inline const Vector3d Vector3d::operator*(double rhs) const{
    Vector3d result;

    result.x = x*rhs;
    result.y = y*rhs;
    result.z = z*rhs;

    return result;
}

inline const Vector3d operator*(double lhs, const Vector3d &rhs){
    Vector3d result;

    result.x = lhs*rhs.x;
    result.y = lhs*rhs.y;
    result.z = lhs*rhs.z;

    return result;
}

inline const Vector3d Vector3d::operator/(double rhs) const{
    Vector3d result;

    result.x = x/rhs;
    result.y = y/rhs;
    result.z = z/rhs;

    return result;
}

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

inline const Vector3d Vector3d::perpendicular(const Vector3d &v) const{
    return *this - dotProduct(*this, v.unit())*v.unit();
}

inline const Vector3d Vector3d::parallel(const Vector3d &v) const{
    return dotProduct(*this, v.unit())*v.unit();
}

inline double Vector3d::norm() const{
    return sqrt(x*x + y*y + z*z);
}

inline double Vector3d::dotProduct(const Vector3d &lhs, const Vector3d &rhs){
    return lhs.x*rhs.x + lhs.y*rhs.y + lhs.z*rhs.z;
}

inline const std::vector<double> Vector3d::getStdVector() const{
    std::vector<double> result;

    result.push_back(x);
    result.push_back(y);
    result.push_back(z);

    return result;
}

inline std::ostream& operator<<(std::ostream &stream, const Vector3d &v){
    stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";

    return stream;
}

};  //End namespace TBTK

#endif