factor.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_MULTIFRONTAL_ZCHOLESKY_FACTOR_H
#define MYRAMATH_MULTIFRONTAL_ZCHOLESKY_FACTOR_H

#include <myramath/multifrontal/detail/llt/factor.h>

#include <myramath/multifrontal/zcholesky/Kernel.h>

#include <myramath/dense/Matrix.h>
#include <myramath/dense/MatrixRange.h>
#include <myramath/dense/LowerMatrix.h>
#include <myramath/dense/LowerMatrixRange.h>
#include <myramath/dense/trsm.h>
#include <myramath/dense/herk.h>
#include <myramath/dense/gemm.h>
#include <myramath/dense/detail/nwork.h>

namespace myra {
namespace multifrontal {
namespace zcholesky {
namespace factor {

template<class Precision> class JobGraphBase : public ::myra::multifrontal::detail::llt::factor::JobGraphBase2<ZCholeskyKernel<Precision> >
  {
  public:

    // Structural typedefs for base class.
    typedef std::complex<Precision> Number;    
    typedef ZCholeskyKernel<Precision> Kernel;    
    typedef ::myra::multifrontal::detail::llt::factor::JobGraphBase2<Kernel> Base;

    // Typedefs related to numeric storage on LContainer
    typedef ::myra::multifrontal::detail::llt::LContainer<Kernel> LContainer;
    typedef LowerMatrix<Number> Diagonal;
    typedef Matrix<Number> Block;

    // Constructor - requires reference to LContainer under construction.
    JobGraphBase(LContainer* in_lcontainer)
       : Base(in_lcontainer), lcontainer(in_lcontainer) { }

    // Virtual copy constructor.
    virtual ::myra::JobGraphBase* clone() const
      { return new JobGraphBase(*this); }

  protected:

    // Factors An(k,k) = Ln(k,k)*Ln(k,k)'
    virtual uint64_t factor(int n, int k)
      {
      // Assign internode contributions if on first k-iteration.
      if (k == 0) this->assign_contributions(n,k); 
      return lcontainer->factor(n,k);
      }

    // Solves Ln(i,k)*Ln(k,k)' = An(i,k)
    virtual uint64_t trsm(int n, int k, int i)
      {
      // Assign internode contributions if on first k-iteration.
      if (k == 0) this->assign_contributions(n,i,k); 
      const Kernel& Ln_kk = this->l(n,k);
      MatrixRange<Number> An_ik = this->a(n,i,k);
      return Ln_kk.solveL(An_ik,'R','H');
      }

    // Downdates An(ij,ij) -= Ln(ij,k)*Ln(ij,k)'
    virtual uint64_t rankk(int n, int k, int ij)
      {
      // Useful constants.
      Precision one(1);
      Precision zero(0);
      // Downdate An(ij,ij) -= Ln(ij,k)*Ln(ij,k)' [herk]
      LowerMatrixRange<Number> An_ij = this->a(n,ij);
      CMatrixRange<Number> Ln_ijk = this->l(n,ij,k);
      // Carefully choose beta and order of steps to avoid workspace initialization.
      Precision beta = k ? one : zero;
      uint64_t w = herk_nwork(An_ij, Ln_ijk, 'N', -one, beta);
      // Add internode contributions if on first k-iteration.
      if (k == 0) this->add_contributions(n,ij);
      return w;
      }
    
    // Downdates An(i,j) -= Ln(i,k)*Ln(j,k)'
    virtual uint64_t gemm(int n, int k, int i, int j)
      {
      // Useful constants.
      Number one(1);
      Number zero(0);
      // Downdate An(i,j) -= Ln(i,k)*Ln(j,k)' [gemm]
      MatrixRange<Number>  An_ij = this->a(n,i,j);
      CMatrixRange<Number> Ln_ik = this->l(n,i,k);
      CMatrixRange<Number> Ln_jk = this->l(n,j,k);
      // Carefully choose beta and order of steps to avoid workspace initialization.
      Number beta = k ? one : zero;
      uint64_t w = gemm_nwork(An_ij, Ln_ik, 'N', Ln_jk, 'H', -one, beta);
      // Add internode contributions if on first k-iteration.
      if (k == 0) this->add_contributions(n,i,j);
      return w;
      }

  private:
  
    // Reference to LContainer under construction.
    LContainer* lcontainer;

  }; // class JobGraph

} } } } // namespace

#endif