b2vec3.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2tensor_calculus.H --
//
//
// written by Thomas Ludwig
//
// Copyright (c) 2017
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef _B2_VEC3_H_
#define _B2_VEC3_H_
 
#include <algorithm>
#include <cmath>
#include <complex>
#include <iostream>
#include <limits>
 
#include "b2csda.H"
 
namespace b2000 {
 
template <typename T>
struct Vec3 {
    T d[3];
 
    Vec3() { std::fill_n(d, 3, T(0)); }
 
    Vec3(const T d_[3]) { std::copy(d_, d_ + 3, d); }
 
    Vec3(const T d1, const T d2, const T d3) {
        d[0] = d1;
        d[1] = d2;
        d[2] = d3;
    }
 
    const T& operator[](const int i) const { return d[i]; }
 
    T& operator[](const int i) { return d[i]; }
 
    const T* data() const { return d; }
 
    T* data() { return d; }
 
    inline T norm() const { return std::sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); }
 
    inline T normalise() {
        const T v = norm();
        if (v != 0) {
            const T f = 1. / v;
            for (int i = 0; i != 3; ++i) { d[i] *= f; }
        }
        return v;
    }
 
    void set_zero() { std::fill_n(d, 3, T(0)); }
 
    Vec3& assign(const Vec3& o) {
        std::copy(o.d, o.d + 3, d);
        return *this;
    }
 
    Vec3& assign(const T o[3]) {
        std::copy(o, o + 3, d);
        return *this;
    }
 
    Vec3& operator=(const Vec3& o) {
        std::copy(o.d, o.d + 3, d);
        return *this;
    }
 
    Vec3& operator+=(const Vec3& o) {
        for (int i = 0; i != 3; ++i) { d[i] += o.d[i]; }
        return *this;
    }
 
    Vec3& operator-=(const Vec3& o) {
        for (int i = 0; i != 3; ++i) { d[i] -= o.d[i]; }
        return *this;
    }
 
    Vec3& operator*=(const T f) {
        for (int i = 0; i != 3; ++i) { d[i] *= f; }
        return *this;
    }
 
    Vec3& operator/=(const T f) {
        for (int i = 0; i != 3; ++i) { d[i] /= f; }
        return *this;
    }
 
    bool operator==(const Vec3& o) const { return (d[0] == o[0] && d[1] == o[1] && d[2] == o[2]); }
 
    bool operator!=(const Vec3& o) const { return (d[0] != o[0] || d[1] != o[1] || d[2] != o[2]); }
};
 
template <typename T>
inline std::ostream& operator<<(std::ostream& o, const Vec3<T>& v) {
    o << "[" << v[0] << "," << v[1] << "," << v[2] << "]";
    return o;
}
 
template <typename T>
inline Vec3<T> operator+(const Vec3<T>& v1, const Vec3<T>& v2) {
    return Vec3<T>(v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]);
}
 
template <typename T>
inline Vec3<T> operator-(const Vec3<T>& v1) {
    return Vec3<T>(-v1[0], -v1[1], -v1[2]);
}
 
template <typename T>
inline Vec3<T> operator-(const Vec3<T>& v1, const Vec3<T>& v2) {
    return Vec3<T>(v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]);
}
 
template <typename T>
inline Vec3<T> operator*(const double f, const Vec3<T>& v) {
    return Vec3<T>(f * v[0], f * v[1], f * v[2]);
}
 
template <typename T>
inline Vec3<T> operator*(const Vec3<T>& v, const double f) {
    return Vec3<T>(f * v[0], f * v[1], f * v[2]);
}
 
template <typename T>
inline T dot(const Vec3<T>& v1, const Vec3<T>& v2) {
    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
}
 
template <typename T>
inline Vec3<T> outer_product(const Vec3<T>& v1, const Vec3<T>& v2) {
    return Vec3<T>(
          v1[1] * v2[2] - v1[2] * v2[1], v1[2] * v2[0] - v1[0] * v2[2],
          v1[0] * v2[1] - v1[1] * v2[0]);
}
 
template <typename T>
inline Vec3<T> normalised(const Vec3<T>& v) {
    Vec3<T> vv(v);
    vv.normalise();
    return vv;
}
 
template <typename T>
inline T norm(const Vec3<T>& v) {
    return std::sqrt(dot(v, v));
}
 
}  // namespace b2000
 
#endif /* _B2_VEC3_H_ */