powersasa 0.2.0

SASA and molecular volume computation using Power diagrams
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#pragma once

#include <cassert>
#include <cmath>
#include <cstddef>
#include <ostream>
#include <type_traits>

template <class T>
struct Vec3 {
  T data[3];

  constexpr Vec3() : data{T{}, T{}, T{}} {}
  constexpr Vec3(T x, T y, T z) : data{x, y, z} {}

  template <class U>
  constexpr explicit Vec3(const Vec3<U>& other)
      : data{static_cast<T>(other.x()), static_cast<T>(other.y()), static_cast<T>(other.z())} {}

  constexpr T& x() { return data[0]; }
  constexpr const T& x() const { return data[0]; }
  constexpr T& y() { return data[1]; }
  constexpr const T& y() const { return data[1]; }
  constexpr T& z() { return data[2]; }
  constexpr const T& z() const { return data[2]; }

  constexpr T& operator[](std::size_t i) {
    assert(i < 3);
    return data[i];
  }

  constexpr const T& operator[](std::size_t i) const {
    assert(i < 3);
    return data[i];
  }

  constexpr void setZero() { data[0] = data[1] = data[2] = T{}; }

  constexpr Vec3 operator+() const { return *this; }
  constexpr Vec3 operator-() const { return Vec3(-data[0], -data[1], -data[2]); }

  constexpr Vec3& operator+=(const Vec3& rhs) {
    data[0] += rhs.data[0];
    data[1] += rhs.data[1];
    data[2] += rhs.data[2];
    return *this;
  }

  constexpr Vec3& operator-=(const Vec3& rhs) {
    data[0] -= rhs.data[0];
    data[1] -= rhs.data[1];
    data[2] -= rhs.data[2];
    return *this;
  }

  template <class U, std::enable_if_t<std::is_arithmetic_v<U>, int> = 0>
  constexpr Vec3& operator*=(const U& scalar) {
    const T s = static_cast<T>(scalar);
    data[0] *= s;
    data[1] *= s;
    data[2] *= s;
    return *this;
  }

  template <class U, std::enable_if_t<std::is_arithmetic_v<U>, int> = 0>
  constexpr Vec3& operator/=(const U& scalar) {
    const T s = static_cast<T>(scalar);
    data[0] /= s;
    data[1] /= s;
    data[2] /= s;
    return *this;
  }

  constexpr T dot(const Vec3& rhs) const {
    return data[0] * rhs.data[0] + data[1] * rhs.data[1] + data[2] * rhs.data[2];
  }

  constexpr Vec3 cross(const Vec3& rhs) const {
    return Vec3(data[1] * rhs.data[2] - data[2] * rhs.data[1],
                data[2] * rhs.data[0] - data[0] * rhs.data[2],
                data[0] * rhs.data[1] - data[1] * rhs.data[0]);
  }

  constexpr T squaredNorm() const { return dot(*this); }

  T norm() const { return static_cast<T>(std::sqrt(squaredNorm())); }
};

template <class T>
constexpr Vec3<T> operator+(Vec3<T> lhs, const Vec3<T>& rhs) {
  lhs += rhs;
  return lhs;
}

template <class T>
constexpr Vec3<T> operator-(Vec3<T> lhs, const Vec3<T>& rhs) {
  lhs -= rhs;
  return lhs;
}

template <class T, class U, std::enable_if_t<std::is_arithmetic_v<U>, int> = 0>
constexpr Vec3<T> operator*(Vec3<T> lhs, const U& scalar) {
  lhs *= scalar;
  return lhs;
}

template <class U, class T, std::enable_if_t<std::is_arithmetic_v<U>, int> = 0>
constexpr Vec3<T> operator*(const U& scalar, Vec3<T> rhs) {
  rhs *= scalar;
  return rhs;
}

template <class T, class U, std::enable_if_t<std::is_arithmetic_v<U>, int> = 0>
constexpr Vec3<T> operator/(Vec3<T> lhs, const U& scalar) {
  lhs /= scalar;
  return lhs;
}

template <class T>
inline std::ostream& operator<<(std::ostream& os, const Vec3<T>& v) {
  os << v.x() << ' ' << v.y() << ' ' << v.z();
  return os;
}