vector.h

Go to the documentation of this file.

// This file is part of HermesCommon
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://www.hpfem.org/.
//
// Hermes2D 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.
//
// Hermes2D 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 Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#ifndef __HERMES_COMMON_VECTOR_H
#define __HERMES_COMMON_VECTOR_H

#include "algebra_utilities.h"
#include "algebra_mixins.h"
#include "mixins.h"

namespace Hermes
{
  namespace Algebra
  {
    template<typename Scalar>
    class HERMES_API Vector : public Hermes::Mixins::Loggable, public Algebra::Mixins::MatrixRhsImportExport < Scalar >
    {
    public:
      Vector();
      Vector(unsigned int size);
      virtual ~Vector() { }

      virtual void alloc(unsigned int ndofs) = 0;
      virtual void free() = 0;
      virtual void finish() { }

      virtual Scalar get(unsigned int idx) const = 0;

      virtual Vector<Scalar>* duplicate() const = 0;

      virtual void extract(Scalar *v) const = 0;

      virtual void zero() = 0;

      virtual Vector<Scalar>* change_sign() = 0;

      virtual void set(unsigned int idx, Scalar y) = 0;

      virtual void add(unsigned int idx, Scalar y) = 0;

      virtual Vector<Scalar>* set_vector(Vector<Scalar>* vec);
      virtual Vector<Scalar>* set_vector(Scalar* vec);

      virtual Vector<Scalar>* add_vector(Vector<Scalar>* vec);
      virtual Vector<Scalar>* add_vector(Scalar* vec);

      virtual Vector<Scalar>* subtract_vector(Vector<Scalar>* vec);
      virtual Vector<Scalar>* subtract_vector(Scalar* vec);

      virtual void add(unsigned int n, unsigned int *idx, Scalar *y) = 0;

      unsigned int get_size() const { return this->size; }
    protected:
      unsigned int size;
    };

    template <typename Scalar>
    class HERMES_API SimpleVector : public Vector < Scalar >
    {
    public:
      SimpleVector();
      SimpleVector(unsigned int size);
      virtual ~SimpleVector();

      virtual void alloc(unsigned int ndofs);
      virtual void free();
      virtual Scalar get(unsigned int idx) const;
      virtual void extract(Scalar *v) const;
      virtual void zero();
      virtual Vector<Scalar>* change_sign();

      Vector<Scalar>* duplicate() const;

      virtual void set(unsigned int idx, Scalar y);
      virtual void add(unsigned int idx, Scalar y);
      virtual void add(unsigned int n, unsigned int *idx, Scalar *y);
      virtual Vector<Scalar>* add_vector(Vector<Scalar>* vec);
      virtual Vector<Scalar>* add_vector(Scalar* vec);
      virtual Vector<Scalar>* subtract_vector(Vector<Scalar>* vec);
      virtual Vector<Scalar>* subtract_vector(Scalar* vec);
      virtual Vector<Scalar>* set_vector(Vector<Scalar>* vec);
      virtual Vector<Scalar>* set_vector(Scalar* vec);

      using Vector<Scalar>::export_to_file;
      using Vector<Scalar>::import_from_file;
      virtual void export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format = "%lf");
      virtual void import_from_file(const char *filename, const char *var_name, MatrixExportFormat fmt);

      Scalar *v;
    };

    template<typename Scalar> HERMES_API
      Vector<Scalar>* create_vector(bool use_direct_solver = false);
  }

  template<typename Scalar>
  double get_l2_norm(Algebra::Vector<Scalar>* vec)
  {
    Scalar val = 0;
    for (unsigned int i = 0; i < vec->get_size(); i++)
    {
      Scalar inc = vec->get(i);
      val = val + inc*conj(inc);
    }
    return sqrt(std::abs(val));
  };

  template<typename Scalar>
  double get_l2_norm(Scalar* vec, int count)
  {
    Scalar val = 0;
    for (unsigned int i = 0; i < count; i++)
    {
      Scalar inc = vec[i];
      val = val + inc*conj(inc);
    }
    return sqrt(std::abs(val));
  }
}
#endif