| /* |
| * Vec2.hh |
| * |
| * Created on: Dec 21, 2011 |
| * Author: cferenba |
| * |
| * Copyright (c) 2012, Los Alamos National Security, LLC. |
| * All rights reserved. |
| * Use of this source code is governed by a BSD-style open-source |
| * license; see top-level LICENSE file for full license text. |
| */ |
| |
| #ifndef VEC2_HH_ |
| #define VEC2_HH_ |
| |
| #include <cmath> |
| #include <string> |
| #include <sstream> |
| #include <ostream> |
| |
| |
| #ifdef __HIPCC__ |
| #include <hip/hip_runtime.h> |
| #define FNQUALIFIERS __host__ __device__ |
| #else |
| #define FNQUALIFIERS |
| #endif |
| |
| // This class is defined with nearly all functions inline, |
| // to give the compiler maximum opportunity to optimize. |
| // Only the functions involving strings and I/O are |
| // out-of-line. |
| |
| #ifndef __HIPCC__ |
| // we are not in CUDA, so need to define our own double2 struct |
| struct double2 |
| { |
| typedef double value_type; |
| double x, y; |
| inline double2() {} |
| inline double2(const double& x_, const double& y_) : x(x_), y(y_) {} |
| inline double2(const double2& v2) : x(v2.x), y(v2.y) {} |
| inline ~double2() {} |
| |
| inline double2& operator=(const double2& v2) |
| { |
| x = v2.x; |
| y = v2.y; |
| return(*this); |
| } |
| |
| inline double2& operator+=(const double2& v2) |
| { |
| x += v2.x; |
| y += v2.y; |
| return(*this); |
| } |
| |
| inline double2& operator-=(const double2& v2) |
| { |
| x -= v2.x; |
| y -= v2.y; |
| return(*this); |
| } |
| |
| inline double2& operator*=(const double& r) |
| { |
| x *= r; |
| y *= r; |
| return(*this); |
| } |
| |
| inline double2& operator/=(const double& r) |
| { |
| x /= r; |
| y /= r; |
| return(*this); |
| } |
| |
| }; // double2 |
| |
| inline double2 make_double2(const double& x_, const double& y_) { |
| return(double2(x_, y_)); |
| } |
| |
| #else |
| // we are in CUDA; double2 is defined but needs op= operators |
| FNQUALIFIERS |
| inline double2& operator*=(double2& v, const double& r) |
| { |
| v.x *= r; |
| v.y *= r; |
| return(v); |
| } |
| |
| FNQUALIFIERS |
| inline double2& operator/=(double2& v, const double& r) |
| { |
| v.x /= r; |
| v.y /= r; |
| return(v); |
| } |
| #endif |
| |
| |
| |
| // unary operators: |
| |
| // unary plus |
| FNQUALIFIERS |
| inline double2 operator+(const double2& v) |
| { |
| return(v); |
| } |
| |
| // unary minus |
| FNQUALIFIERS |
| inline double2 operator-(const double2& v) |
| { |
| return(make_double2(-v.x, -v.y)); |
| } |
| |
| |
| // binary operators: |
| |
| // // multiply vector by scalar |
| // FNQUALIFIERS |
| // inline double2 operator*(const double2& v, const double& r) |
| // { |
| // return(make_double2(v.x * r, v.y * r)); |
| // } |
| |
| // // multiply scalar by vector |
| // FNQUALIFIERS |
| // inline double2 operator*(const double& r, const double2& v) |
| // { |
| // return(make_double2(v.x * r, v.y * r)); |
| // } |
| |
| // divide vector by scalar |
| FNQUALIFIERS |
| inline double2 operator/(const double2& v, const double& r) |
| { |
| double rinv = (double) 1. / r; |
| return(make_double2(v.x * rinv, v.y * rinv)); |
| } |
| |
| |
| // other vector operations: |
| |
| // dot product |
| FNQUALIFIERS |
| inline double dot(const double2& v1, const double2& v2) |
| { |
| return(v1.x * v2.x + v1.y * v2.y); |
| } |
| |
| // cross product (2D) |
| FNQUALIFIERS |
| inline double cross(const double2& v1, const double2& v2) |
| { |
| return(v1.x * v2.y - v1.y * v2.x); |
| } |
| |
| // length |
| FNQUALIFIERS |
| inline double length(const double2& v) |
| { |
| return(sqrt(v.x * v.x + v.y * v.y)); |
| } |
| |
| // length squared |
| FNQUALIFIERS |
| inline double length2(const double2& v) |
| { |
| return(v.x * v.x + v.y * v.y); |
| } |
| |
| // rotate 90 degrees counterclockwise |
| FNQUALIFIERS |
| inline double2 rotateCCW(const double2& v) |
| { |
| return(make_double2(-v.y, v.x)); |
| } |
| |
| // rotate 90 degrees clockwise |
| FNQUALIFIERS |
| inline double2 rotateCW(const double2& v) |
| { |
| return(make_double2(v.y, -v.x)); |
| } |
| |
| // project v onto subspace perpendicular to u |
| // u must be a unit vector |
| FNQUALIFIERS |
| inline double2 project(double2& v, const double2& u) |
| { |
| // assert(length2(u) == 1.); |
| return v - dot(v, u) * u; |
| } |
| |
| |
| // miscellaneous: |
| |
| //// output to stream |
| //std::ostream& operator<<(std::ostream& os, const double2& v) |
| //{ |
| // os << "(" << v.x << ", " << v.y << ")"; |
| // return os; |
| //} |
| |
| //// conversion to string |
| //std::string makeString(const double2& v) |
| //{ |
| // std::ostringstream oss; |
| // oss << v; |
| // return oss.str(); |
| //} |
| |
| |
| // convenience typedefs: |
| |
| //typedef Vec2<float> float2; |
| //typedef Vec2<double> double2; |
| |
| |
| #endif /* VEC2_HH_ */ |