Tools/Math/LA_Vector.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
/**
 * @file LA_Vector.h
 * Contains class LinAlg::Vector
 *
 * @author <a href="mailto:stefanuhrig@gmx.net">Stefan Uhrig</a>
 */
//------------------------------------------------------------------------------
#ifndef LINALG_VECTOR_H_INCLUDED
#define LINALG_VECTOR_H_INCLUDED
//------------------------------------------------------------------------------
#include <cstdlib>
#include <iosfwd>
#include <string>
#include "LA_Exception.h"
#include "Vector3.h"
#include "Tools/Streams/InOut.h"
//------------------------------------------------------------------------------
namespace LA
{
//------------------------------------------------------------------------------
class Matrix;
//------------------------------------------------------------------------------
/**
 * @author <a href="mailto:stefanuhrig@gmx.net">Stefan Uhrig</a>
 *
 * Represents a vector with arbitrary entries of type double.
 */
class Vector
{
public:
  /**
   * Standard constructor. Constructed vector has no entries.
   */
  Vector();

  /**
   * Constructs a vector with the specified dimension. Entries are initialized
   * with 0.0.
   * @param n Dimension of vector.
   */
  Vector(int n);
  
  /**
   * Constructs a vector with the specified dimension. Entries are intialized
   * with the values in the passed double array.
   * @param n Dimension of vector.
   * @param v Array with double values that are used to initialize the vector.
   */
  Vector(int n, const double* v);

  /**
   * Copy constructor.
   * @param v Vector to copy.
   */
  Vector(const Vector& v);
  
  /**
   * Copy constructor.
   * @param v Vector3 to copy.
   */
  Vector(const Vector3<double>& v);

  /**
   * Destructor.
   */
  virtual ~Vector();

public:
  
  /**
   * Recreates the vector with specified dimension and initalizes all entries
   * to 0.0.
   * @param n Dimension of recreated vector.
   */
  void create(int n);
  
  /**
   * Recreates the vector with specified dimension and initalizes all entries
   * with the values in the passed array.
   * @param n Dimension of recreated vector.
   * @param v Array with double values that are used to initialize the vector.
   */
  void create(int n, const double* v);
  
  /**
   * Copy operator.
   * @param v Vector to copy.
   * @return Reference to this vector.
   */
  Vector& operator=(const Vector& v);

  /**
   * Copy operator.
   * @param v Vector3 to copy.
   * @return Reference to this vector.
   */
  Vector& operator=(const Vector3<double>& v);

  /**
   * Constant element access operator (zero-based).
   * @param i Index of element to access (zero-based).
   * @return Constant reference to entry.
   */
  const double& operator[](int i) const;
  
  /**
   * Element access operator (zero-based).
   * @param i Index of element to access (zero-based).
   * @return Reference to entry.
   */
  double& operator[](int i);
  
  /**
   * Constant element access operator (one-based).
   * @param i Index of element to access (one-based).
   * @return Constant reference to entry.
   */
  const double& operator()(int i) const;
  
  /**
   * Element access operator (one-based).
   * @param i Index of element to access (one-based).
   * @return Reference to entry.
   */
  double& operator()(int i);
  
  /**
   * Dimension of vector.
   * @return Dimension of vector.
   */
  int dim() const;

  /**
   * Extracts a subvector.
   * @param index Index of first entry to extract (one-based).
   * @param length Number of entries to extract.
   * @return The subvector.
   */
  Vector sub(int index, int length) const;

  /**
   * Sets a subvector inside this vector.
   * @param index Index where to map the first entry of subv
   * @param subv The subvector to set.
   */
  void set_sub(int index, const Vector& subv);

  /**
   * Adds the passed vector to this vector.
   * @param v Vector to add.
   * @return Reference to this vector.
   */
  Vector& operator+=(const Vector& v);
  
  /**
   * Substracts the passed vector from this vector.
   * @param v Vector to subtract.
   * @return Reference to this vector.
   */
  Vector& operator-=(const Vector& v);
  
  /**
   * Multiplies this vector with the passed scalar.
   * @param s Scalar to multiply this vector with.
   * @return Reference to this vector.
   */
  Vector& operator*=(const double& s);
  
  /**
   * Divides this vector by the passed scalar.
   * @param s Scalar to divide this vector by.
   * @return Reference to this vector.
   */
  Vector& operator/=(const double& s);

  /**
   * Returns a human-readable representation of the vector.
   * @return Human-readable representation of the vector.
   */
  std::string asString() const;

  /**
   * Returns the euclidian length of the vector.
   * @return The euclidian length of the vector.
   */
  double length() const;
  
private:
  void destroy();

private:
  int n;
  double* content;

  friend Vector operator+(const Vector& v1, const Vector& v2);
  friend Vector operator-(const Vector& v1, const Vector& v2);
  friend Vector operator*(const double& s, const Vector& v);
  friend Vector operator*(const Vector& v, const double& s);
  friend Vector operator*(const Matrix& M, const Vector& v);
  friend Vector operator/(const Vector& v, const double& s);
  friend double operator*(const Vector& v1, const Vector& v2);
  friend Matrix operator*(const Matrix& M1, const Matrix& M2);
  friend Out& operator<<(Out& stream, const Vector& v);
  friend In& operator>>(In& stream, Vector& v);
  friend Out& operator<<(Out& stream, const Matrix& M);
  friend In& operator>>(In& stream, Matrix& M);

  friend class Matrix;
};
//------------------------------------------------------------------------------

/**
 * Adds to vectors.
 * @param v1 First vector.
 * @param v2 Second vector.
 * @return v1 + v2.
 */
Vector operator+(const Vector& v1, const Vector& v2);

/**
 * Subtracts to vectors.
 * @param v1 First vector.
 * @param v2 Second vector.
 * @return v1 - v2.
 */
Vector operator-(const Vector& v1, const Vector& v2);

/**
 * Multiplies a vector with a scalar.
 * @param s Scalar.
 * @param v Vector.
 * @return s*v.
 */
Vector operator*(const double& s, const Vector& v);

/**
 * Multiplies a vector with a scalar.
 * @param v Vector.
 * @param s Scalar.
 * @return v*s.
 */
Vector operator*(const Vector& v, const double& s);

/**
 * Divides a vector by a scalar.
 * @param v Vector.
 * @param s Scalar.
 * @return v/s.
 */
Vector operator/(const Vector& v, const double& s);

/**
 * Calculates the inner product of two vector.
 * @param v1 First vector.
 * @param v2 Second vector.
 * @return <v1, v2>.
 */
double operator*(const Vector& v1, const Vector& v2);
//------------------------------------------------------------------------------

/**
 * Prints a user-readable representation of the vector.
 * @param out An ostream.
 * @param v Vector to output.
 * @return Reference to passed ostream.
 */
std::ostream& operator<<(std::ostream& out, const Vector& v);

/**
 * Out operator for GT-streams.
 * @param stream Out-stream.
 * @param v Vector to output.
 * @return Reference to passed Out-stream.
 */
Out& operator<<(Out& stream, const Vector& v);

/**
 * In operator for GT-streams.
 * @param stream In-stream.
 * @param v Vector to read to.
 * @return Reference to passed In-stream.
 */
In& operator>>(In& stream, Vector& v);
//------------------------------------------------------------------------------
}
//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------

---