CoinDenseVector.hpp

Go to the documentation of this file.

/* $Id: CoinDenseVector.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CoinDenseVector_H
#define CoinDenseVector_H

#if defined(_MSC_VER)
// Turn off compiler warning about long names
#pragma warning(disable : 4786)
#endif

#include <cassert>
#include <cstdlib>
#include <cmath>
#include "CoinHelperFunctions.hpp"

//#############################################################################
template < typename T >
void CoinDenseVectorUnitTest(T dummy);

//#############################################################################
template < typename T >
class CoinDenseVector {
private:
  int nElements_;
  T *elements_;

public:
  inline int getNumElements() const { return nElements_; }
  inline int size() const { return nElements_; }
  inline const T *getElements() const { return elements_; }
  inline T *getElements() { return elements_; }

  //-------------------------------------------------------------------
  // Set indices and elements
  //-------------------------------------------------------------------
  void clear();
  CoinDenseVector &operator=(const CoinDenseVector &);
  T &operator[](int index) const;

  void setVector(int size, const T *elems);

  void setConstant(int size, T elems);

  void setElement(int index, T element);
  void resize(int newSize, T fill = T());

  void append(const CoinDenseVector &);

  inline T oneNorm() const
  {
    T norm = 0;
    for (int i = 0; i < nElements_; i++)
      norm += CoinAbs(elements_[i]);
    return norm;
  }
  inline double twoNorm() const
  {
    double norm = 0.;
    for (int i = 0; i < nElements_; i++)
      norm += elements_[i] * elements_[i];
    // std namespace removed because it was causing a compile
    // problem with Microsoft Visual C++
    return /*std::*/ sqrt(norm);
  }
  inline T infNorm() const
  {
    T norm = 0;
    for (int i = 0; i < nElements_; i++)
      norm = CoinMax(norm, CoinAbs(elements_[i]));
    return norm;
  }
  inline T sum() const
  {
    T sume = 0;
    for (int i = 0; i < nElements_; i++)
      sume += elements_[i];
    return sume;
  }
  inline void scale(T factor)
  {
    for (int i = 0; i < nElements_; i++)
      elements_[i] *= factor;
    return;
  }

  void operator+=(T value);
  void operator-=(T value);
  void operator*=(T value);
  void operator/=(T value);

  CoinDenseVector();
  CoinDenseVector(int size, const T *elems);
  CoinDenseVector(int size, T element = T());
  CoinDenseVector(const CoinDenseVector &);

  ~CoinDenseVector();

private:
  void gutsOfSetVector(int size, const T *elems);
  void gutsOfSetConstant(int size, T value);
};

//#############################################################################

template < typename T >
inline CoinDenseVector< T > operator+(const CoinDenseVector< T > &op1,
  const CoinDenseVector< T > &op2)
{
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] + elements2[i];
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator-(const CoinDenseVector< T > &op1,
  const CoinDenseVector< T > &op2)
{
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] - elements2[i];
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator*(const CoinDenseVector< T > &op1,
  const CoinDenseVector< T > &op2)
{
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] * elements2[i];
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator/(const CoinDenseVector< T > &op1,
  const CoinDenseVector< T > &op2)
{
  assert(op1.size() == op2.size());
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  const T *elements2 = op2.getElements();
  T *elements3 = op3.getElements();
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] / elements2[i];
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator+(const CoinDenseVector< T > &op1, T value)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] + dvalue;
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator-(const CoinDenseVector< T > &op1, T value)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] - dvalue;
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator*(const CoinDenseVector< T > &op1, T value)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] * dvalue;
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator/(const CoinDenseVector< T > &op1, T value)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] / dvalue;
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator+(T value, const CoinDenseVector< T > &op1)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] + dvalue;
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator-(T value, const CoinDenseVector< T > &op1)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = dvalue - elements1[i];
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator*(T value, const CoinDenseVector< T > &op1)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = elements1[i] * dvalue;
  return op3;
}

template < typename T >
inline CoinDenseVector< T > operator/(T value, const CoinDenseVector< T > &op1)
{
  int size = op1.size();
  CoinDenseVector< T > op3(size);
  const T *elements1 = op1.getElements();
  T *elements3 = op3.getElements();
  double dvalue = value;
  for (int i = 0; i < size; i++)
    elements3[i] = dvalue / elements1[i];
  return op3;
}

#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/