t8_vec.h

Go to the documentation of this file.

/*
  This file is part of t8code.
  t8code is a C library to manage a collection (a forest) of multiple
  connected adaptive space-trees of general element classes in parallel.
 
  Copyright (C) 2015 the developers
 
  t8code is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
 
  t8code is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with t8code; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
#ifndef T8_VEC_H
#define T8_VEC_H
 
#include <t8.h>
 
static inline double
t8_vec_norm (const double vec[3])
{
  double norm = 0;
 
  for (int i = 0; i < 3; i++) {
    norm += vec[i] * vec[i];
  }
  return sqrt (norm);
}
 
static inline void
t8_vec_normalize (double vec[3])
{
  const double inv_norm = 1.0 / t8_vec_norm (vec);
 
  for (int i = 0; i < 3; i++) {
    vec[i] *= inv_norm;
  }
}
 
static inline void
t8_vec_copy (const double vec_in[3], double vec_out[3])
{
  for (int i = 0; i < 3; i++) {
    vec_out[i] = vec_in[i];
  }
}
 
static inline double
t8_vec_dist (const double vec_x[3], const double vec_y[3])
{
  double dist = 0;
 
  for (int i = 0; i < 3; i++) {
    dist += SC_SQR (vec_x[i] - vec_y[i]);
  }
  return sqrt (dist);
}
 
static inline void
t8_vec_ax (double vec_x[3], const double alpha)
{
  for (int i = 0; i < 3; i++) {
    vec_x[i] *= alpha;
  }
}
 
static inline void
t8_vec_axy (const double vec_x[3], double vec_y[3], const double alpha)
{
  for (int i = 0; i < 3; i++) {
    vec_y[i] = vec_x[i] * alpha;
  }
}
 
static inline void
t8_vec_axb (const double vec_x[3], double vec_y[3], const double alpha, const double b)
{
  for (int i = 0; i < 3; i++) {
    vec_y[i] = alpha * vec_x[i] + b;
  }
}
 
static inline void
t8_vec_axpy (const double vec_x[3], double vec_y[3], const double alpha)
{
  for (int i = 0; i < 3; i++) {
    vec_y[i] += alpha * vec_x[i];
  }
}
 
static inline void
t8_vec_axpyz (const double vec_x[3], const double vec_y[3], double vec_z[3], const double alpha)
{
  for (int i = 0; i < 3; i++) {
    vec_z[i] = vec_y[i] + alpha * vec_x[i];
  }
}
 
static inline double
t8_vec_dot (const double vec_x[3], const double vec_y[3])
{
  double dot = 0;
 
  for (int i = 0; i < 3; i++) {
    dot += vec_x[i] * vec_y[i];
  }
  return dot;
}
 
static inline void
t8_vec_cross (const double vec_x[3], const double vec_y[3], double cross[3])
{
  for (int i = 0; i < 3; i++) {
    cross[i] = vec_x[(i + 1) % 3] * vec_y[(i + 2) % 3] - vec_x[(i + 2) % 3] * vec_y[(i + 1) % 3];
  }
}
 
static inline void
t8_vec_diff (const double vec_x[3], const double vec_y[3], double diff[3])
{
  for (int i = 0; i < 3; i++) {
    diff[i] = vec_x[i] - vec_y[i];
  }
}
 
static inline int
t8_vec_eq (const double vec_x[3], const double vec_y[3], const double tol)
{
  T8_ASSERT (tol > 0);
  return fabs (vec_x[0] - vec_y[0]) <= tol && fabs (vec_x[1] - vec_y[1]) <= tol && fabs (vec_x[2] - vec_y[2]) <= tol;
}
 
static inline void
t8_vec_rescale (double vec[3], const double new_length)
{
  t8_vec_normalize (vec);
  t8_vec_ax (vec, new_length);
}
 
static inline void
t8_vec_tri_normal (const double p1[3], const double p2[3], const double p3[3], double normal[3])
{
  double a[3]; /* First triangle side. */
  double b[3]; /* Second triangle side. */
 
  a[0] = p2[0] - p1[0];
  a[1] = p2[1] - p1[1];
  a[2] = p2[2] - p1[2];
 
  b[0] = p3[0] - p1[0];
  b[1] = p3[1] - p1[1];
  b[2] = p3[2] - p1[2];
 
  t8_vec_cross (a, b, normal);
}
 
static inline void
t8_vec_swap (double p1[3], double p2[3])
{
  double tmp;
  for (int i = 0; i < 3; i++) {
    tmp = p1[i];
    p1[i] = p2[i];
    p2[i] = tmp;
  }
}
 
#endif /* !T8_VEC_H */