math_vector_functions.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 ��7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., N��gel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program 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 Lesser General Public License for more details.
 */
 
#ifndef __H__COMMON__MATH_VECTOR_FUNCTIONS__
#define __H__COMMON__MATH_VECTOR_FUNCTIONS__
 
#include "math_vector.h"
 
namespace ug
{
 
 
 
template <typename vector_target_t, typename vector_source_t>
void VecCopy(vector_target_t& target, const vector_source_t& source,
       typename vector_target_t::value_type fill);
 
// Append Vector
 
// vOut += v1
template <typename vector_t>
inline
void
VecAppend(vector_t& vOut, const vector_t& v1);
 
// vOut = v1 + v2
template <typename vector_t>
inline
void
VecAppend(vector_t& vOut, const vector_t& v1, const vector_t& v2);
 
// vOut += v1 + v2 + v3
template <typename vector_t>
inline
void
VecAppend(vector_t& vOut, const vector_t& v1, const vector_t& v2,
              const vector_t& v3);
 
// vOut += v1 + v2 + v3 + v4
template <typename vector_t>
inline
void
VecAppend(vector_t& vOut, const vector_t& v1, const vector_t& v2,
              const vector_t& v3, const vector_t& v4);
 
// Scale and Append Vectors
 
// vOut += s1*v1
template <typename vector_t>
inline
void
VecScaleAppend(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1);
 
// vOut += s1*v1 + s2*v2
template <typename vector_t>
inline
void
VecScaleAppend(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1,
                 typename vector_t::value_type s2, const vector_t& v2);
 
// vOut += s1*v1 + s2*v2 + s3*v3
template <typename vector_t>
inline
void
VecScaleAppend(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1,
                 typename vector_t::value_type s2, const vector_t& v2,
                 typename vector_t::value_type s3, const vector_t& v3);
 
// vOut += s1*v1 + s2*v2 + s3*v3 + s4*v4
template <typename vector_t>
inline
void
VecScaleAppend(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1,
                 typename vector_t::value_type s2, const vector_t& v2,
                 typename vector_t::value_type s3, const vector_t& v3,
                 typename vector_t::value_type s4, const vector_t& v4);
 
 
// Addition of Vectors
 
// vOut = v1 + v2
template <typename vector_t>
inline
void
VecAdd(vector_t& vOut, const vector_t& v1, const vector_t& v2);
 
// vOut = v1 + v2 + v3
template <typename vector_t>
inline
void
VecAdd(vector_t& vOut, const vector_t& v1, const vector_t& v2,
              const vector_t& v3);
 
// vOut = v1 + v2 + v3 + v4
template <typename vector_t>
inline
void
VecAdd(vector_t& vOut, const vector_t& v1, const vector_t& v2,
              const vector_t& v3, const vector_t& v4);
 
// Subtraction of Vectors
 
// vOut = v1 - v2
template <typename vector_t>
inline
void
VecSubtract(vector_t& vOut, const vector_t& v1, const vector_t& v2);
 
// Component-wise exponentiation of a vector
template <typename vector_t>
inline
void
VecPow(vector_t& vOut, const vector_t& v1, typename vector_t::value_type s);
 
 
// Scaling of a Vector
 
// vOut = s * v
template <typename vector_t>
inline
void
VecScale(vector_t& vOut, const vector_t& v, typename vector_t::value_type s);
 
// Scaled Addition of Vectors
 
// vOut = s1*v1 + s2*v2
template <typename vector_t>
inline
void
VecScaleAdd(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1,
                 typename vector_t::value_type s2, const vector_t& v2);
 
// vOut = s1*v1 + s2*v2 + s3*v3
template <typename vector_t>
inline
void
VecScaleAdd(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1,
                 typename vector_t::value_type s2, const vector_t& v2,
                 typename vector_t::value_type s3, const vector_t& v3);
 
// vOut = s1*v1 + s2*v2 + s3*v3 + s4*v4
template <typename vector_t>
inline
void
VecScaleAdd(vector_t& vOut, typename vector_t::value_type s1, const vector_t& v1,
                 typename vector_t::value_type s2, const vector_t& v2,
                 typename vector_t::value_type s3, const vector_t& v3,
                 typename vector_t::value_type s4, const vector_t& v4);
 
// Interpolation of Vectors
 
//  performs linear interpolation between two Vectors.
template <typename vector_t>
inline
void
VecInterpolateLinear(vector_t& vOut, const vector_t& v1, const vector_t& v2,
            typename vector_t::value_type interpAmount);
 
// Length of Vectors
 
template <typename vector_t>
inline
typename vector_t::value_type
VecLengthSq(const vector_t& v);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecLength(const vector_t& v);
 
// Distance of Vectors
 
template <typename vector_t>
inline
typename vector_t::value_type
VecDistanceSq(const vector_t& v1, const vector_t& v2);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecDistance(const vector_t& v1, const vector_t& v2);
 
 
// Dot Product
template <typename vector_t>
inline
typename vector_t::value_type
VecDot(const vector_t& v1, const vector_t& v2);
 
// Angle
template <typename vector_t>
inline
typename vector_t::value_type
VecAngle(const vector_t& v1, const vector_t& v2);
 
// Angle
 
template <typename vector_t>
inline
typename vector_t::value_type
VecAngleNorm(const vector_t& v1, const vector_t& v2);
 
// Cross Product
template <typename vector_t>
inline
void
VecCross(vector_t& vOut, const vector_t& v1, const vector_t& v2);
 
// Generalized cross Product
template <size_t dim>
inline void GenVecCross
(
  MathVector<dim> & result, 
  const MathVector<dim> & v_1, const MathVector<dim> & v_2
);
 
// Normalize a Vector
template <typename vector_t>
inline
void
VecNormalize(vector_t& vOut, const vector_t& v);
 
// CalculateTriangleNormalNoNormalize
//TODO: This method should not be part of the core-math methods.
//    Instead it should be moved to a seperate math-util file.
template <typename vector_t>
inline
void
CalculateTriangleNormalNoNormalize(vector_t& vOut, const vector_t& v1,
            const vector_t& v2, const vector_t& v3);
 
// CalculateTriangleNormal
//TODO: This method should not be part of the core-math methods.
//    Instead it should be moved to a seperate math-util file.
template <typename vector_t>
inline
void
CalculateTriangleNormal(vector_t& vOut, const vector_t& v1,
            const vector_t& v2, const vector_t& v3);
 
 
// Operations with scalar
 
template <typename vector_t>
inline
void
VecSet(vector_t& vInOut, typename vector_t::value_type s);
 
template <typename vector_t>
inline
void
VecAdd(vector_t& vOut, const vector_t& v, typename vector_t::value_type s);
 
template <typename vector_t>
inline
void
VecSubtract(vector_t& vOut, const vector_t& v, typename vector_t::value_type s);
 
// Norms
template <typename vector_t>
inline
typename vector_t::value_type
VecTwoNorm(const vector_t& v);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecTwoNormSq(const vector_t& v);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecOneNorm(const vector_t& v);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecPNorm(const vector_t& v, unsigned int p);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecMaxNorm(const vector_t& v);
 
template <typename vector_t>
inline
typename vector_t::value_type
VecInftyNorm(const vector_t& v);
 
// end group vectors
 
 
// Elementwise operations
 
template <typename vector_t>
inline
void
VecElemProd(vector_t& vOut, const vector_t& v1, const vector_t& v2);
 
template <typename vector_t>
inline
void
VecElemSqrt(vector_t& vOut, const vector_t& v1);
 
template <typename vector_t>
inline
bool
VecAbsIsLess(const vector_t& v1, const vector_t& v2);
 
template <typename vector_t>
inline
bool
VecAbsIsLess(const vector_t& v1, const typename vector_t::value_type s);
 
template <typename vector_t>
inline
bool
VecIsInBB(const vector_t& v, const vector_t& low, const vector_t& high);
 
}// end of namespace
 
//  include a general, but not very fast implementation of the declared methods above.
#include "math_vector_functions_common_impl.hpp"
 
#endif /* __H__COMMON__MATH_MathVector_FUNCTIONS__ */