LinearAlgebra.h

Go to the documentation of this file.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
#pragma once
 
#include <alien/utils/Precomp.h>
 
#include <memory>
#include <string>
 
#include <alien/core/backend/BackEnd.h>
#include <alien/core/backend/IInternalLinearAlgebraT.h>
 
#include <alien/expression/solver/ILinearAlgebra.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Space;
class IVector;
class IMatrix;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class Tag, class TagV = Tag>
class LinearAlgebra : public ILinearAlgebra
{
 public:
  template <typename... T>
  LinearAlgebra(T... args)
  : m_algebra(AlgebraTraits<Tag>::algebra_factory(args...))
  {}

  virtual ~LinearAlgebra();

  Real norm0(const IVector& x) const;

  Real norm1(const IVector& x) const;

  Real norm2(const IVector& x) const;

  Real normInf(const IVector& x) const;

  void mult(const IMatrix& a, const IVector& x, IVector& r) const;

  void axpy(Real alpha, const IVector& x, IVector& y) const;

  void aypx(Real alpha, IVector& y, const IVector& x) const;

  void copy(const IVector& x, IVector& r) const;

  Real dot(const IVector& x, const IVector& y) const;

  void scal(Real alpha, IVector& x) const;

  void diagonal(const IMatrix& a, IVector& x) const;

  void reciprocal(IVector& x) const;

  void pointwiseMult(const IVector& x, const IVector& y, IVector& w) const;

  void mult(const IMatrix& a, const UniqueArray<Real>& x, UniqueArray<Real>& r) const;

  void axpy(const Real& alpha, const UniqueArray<Real>& x, UniqueArray<Real>& r) const;

  void aypx(Real alpha, UniqueArray<Real>& y, const UniqueArray<Real>& x) const;

  void copy(const UniqueArray<Real>& x, UniqueArray<Real>& r) const;

  Real dot(
  Integer local_size, const UniqueArray<Real>& x, const UniqueArray<Real>& y) const;

  void scal(Real alpha, UniqueArray<Real>& x) const;

  void dump(IMatrix const& a, std::string const& filename) const;

  void dump(IVector const& x, std::string const& filename) const;
 
 private:
  typedef typename AlgebraTraits<Tag>::algebra_type KernelAlgebra;
  std::unique_ptr<KernelAlgebra> m_algebra;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/