AMROC Main     Blockstructured Adaptive Mesh Refinement in object-oriented C++


Main Page   Class Hierarchy   Compound List   File List  

Vector12.h File Reference

Vector implementation. More...

#include "CompConf.h"
#include "generic.h"
#include <iostream.h>
#include <assert.h>

Include dependency graph for Vector12.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Compounds

class  Vector
 Vector implementation. More...


Defines

#define Vector(dim)   name2(Vector,dim)
#define VectorName
#define Vector_Vector_Operator(ope, op)
#define Vector_Scalar_Operator(ope, op)
#define Vector_Vector_RelOperator(op)
#define Vector_Vector_RelOperator(op)
#define Vector_Scalar_RelOperator(op)
#define Vector_Scalar_RelOperator(op)
#define Global_Vector_Scalar_Operator(op)
#define Global_Vector_Function(fct)
#define Vector_Vector_Functions(NameTo, NameFrom, ope)

Functions

template<class DataType> ostream & operator<< (ostream &os, const Vector< DataType > &v)
template<class DataType> Vector< DataType > Min (const Vector< DataType > &x, const Vector< DataType > &y)
template<class DataType> Vector< DataType > Max (const Vector< DataType > &x, const Vector< DataType > &y)
template<class DataType> double abs (const Vector< DataType > &x)
template<class DataType> DataType mincomp (const Vector< DataType > &x)
template<class DataType> DataType maxcomp (const Vector< DataType > &x)
template<class DataType> Vector< DataType > operator+ (const DataType &v, const Vector< DataType > &x)
template<class DataType> Vector< DataType > operator- (const DataType &v, const Vector< DataType > &x)
template<class DataType> Vector< DataType > operator * (const DataType &v, const Vector< DataType > &x)
template<class DataType> Vector< DataType > operator/ (const DataType &v, const Vector< DataType > &x)
template<class DataType> Vector< DataType > fabs (const Vector< DataType > &x)
template<class DataType> Vector< DataType > sqrt (const Vector< DataType > &x)
template<class DataType, class VectorType> void equals_to (Vector< DataType > &x, const VectorType &y)
template<class DataType, class VectorType> void equals_from (VectorType &x, const Vector< DataType > &y)
template<class DataType, class VectorType> void plus_to (Vector< DataType > &x, const VectorType &y)
template<class DataType, class VectorType> void plus_from (VectorType &x, const Vector< DataType > &y)
template<class DataType, class VectorType> void minus_to (Vector< DataType > &x, const VectorType &y)
template<class DataType, class VectorType> void minus_from (VectorType &x, const Vector< DataType > &y)
template<class DataType, class VectorType> void multiply_to (Vector< DataType > &x, const VectorType &y)
template<class DataType, class VectorType> void multiply_from (VectorType &x, const Vector< DataType > &y)
template<class DataType, class VectorType> void divide_to (Vector< DataType > &x, const VectorType &y)
template<class DataType, class VectorType> void divide_from (VectorType &x, const Vector< DataType > &y)


Detailed Description

Vector implementation.

Author:
Ralf Deiterding
Version:
1.0
Date:
Jan-2002

Definition in file Vector12.h.


Define Documentation

#define Global_Vector_Function fct   
 

Value:

template <class DataType>                                                 \
inline Vector(12)<DataType> fct(const Vector(12)<DataType> &x)              \
   {                                                                      \
      Vector(12)<DataType> ret;                                            \
      ret[0] = fct(x[0]);                                                 \
      ret[1] = fct(x[1]);                                                 \
      ret[2] = fct(x[2]);                                                 \
      ret[3] = fct(x[3]);                                                 \
      ret[4] = fct(x[4]);                                                 \
      ret[5] = fct(x[5]);                                                 \
      ret[6] = fct(x[6]);                                                 \
      ret[7] = fct(x[7]);                                                 \
      ret[8] = fct(x[8]);                                                 \
      ret[9] = fct(x[9]);                                                 \
      ret[10] = fct(x[10]);                                               \
      ret[11] = fct(x[11]);                                               \
      return(ret);                                                        \
     }

Definition at line 439 of file Vector12.h.

#define Global_Vector_Scalar_Operator op   
 

Value:

template <class DataType>                                                  \
inline Vector(12)<DataType> operator op (const DataType &v,                 \
   const Vector(12)<DataType> &x)                                           \
   { return(x op v); }

Definition at line 426 of file Vector12.h.

#define Vector_Scalar_RelOperator op   
 

Value:

inline int operator op (const DataType &v) const             \
     { return(                                                  \
               (data_[0] op v)                                  \
            || (data_[1] op v)                                  \
            || (data_[2] op v)                                  \
            || (data_[3] op v)                                  \
            || (data_[4] op v)                                  \
            || (data_[5] op v)                                  \
            || (data_[6] op v)                                  \
            || (data_[7] op v)                                  \
            || (data_[8] op v)                                  \
            || (data_[9] op v)                                  \
            || (data_[10] op v)                                 \
            || (data_[11] op v)                                 \
              ); }

Definition at line 271 of file Vector12.h.

#define Vector_Scalar_RelOperator op   
 

Value:

inline int operator op (const DataType &v) const             \
     { return(                                                  \
               (data_[0] op v)                                  \
            && (data_[1] op v)                                  \
            && (data_[2] op v)                                  \
            && (data_[3] op v)                                  \
            && (data_[4] op v)                                  \
            && (data_[5] op v)                                  \
            && (data_[6] op v)                                  \
            && (data_[7] op v)                                  \
            && (data_[8] op v)                                  \
            && (data_[9] op v)                                  \
            && (data_[10] op v)                                 \
            && (data_[11] op v)                                 \
             ); }

Definition at line 271 of file Vector12.h.

#define Vector_Vector_RelOperator op   
 

Value:

inline int operator op (const TVector &x) const              \
     { return(                                                  \
               (data_[0] op x.data_[0])                         \
            || (data_[1] op x.data_[1])                         \
            || (data_[2] op x.data_[2])                         \
            || (data_[3] op x.data_[3])                         \
            || (data_[4] op x.data_[4])                         \
            || (data_[5] op x.data_[5])                         \
            || (data_[6] op x.data_[6])                         \
            || (data_[7] op x.data_[7])                         \
            || (data_[8] op x.data_[8])                         \
            || (data_[9] op x.data_[9])                         \
            || (data_[10] op x.data_[10])                       \
            || (data_[11] op x.data_[11])                       \
             ) ; }

Definition at line 227 of file Vector12.h.

#define Vector_Vector_RelOperator op   
 

Value:

inline int operator op (const TVector &x) const              \
     { return(                                                  \
               (data_[0] op x.data_[0])                         \
            && (data_[1] op x.data_[1])                         \
            && (data_[2] op x.data_[2])                         \
            && (data_[3] op x.data_[3])                         \
            && (data_[4] op x.data_[4])                         \
            && (data_[5] op x.data_[5])                         \
            && (data_[6] op x.data_[6])                         \
            && (data_[7] op x.data_[7])                         \
            && (data_[8] op x.data_[8])                         \
            && (data_[9] op x.data_[9])                         \
            && (data_[10] op x.data_[10])                       \
            && (data_[11] op x.data_[11])                       \
             ) ; }

Definition at line 227 of file Vector12.h.


Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download



AMROC Main      Home      Contact
last update: 06/01/04