summation.h

Go to the documentation of this file.

#ifndef __INT_SUMMATION_H__
#define __INT_SUMMATION_H__

#include <assert.h>
#include "sum_tsr.h"
#include "spsum_tsr.h"

namespace CTF_int {
  class tensor; 
  class topology; 

  class summation {
     public:
      tensor * A;
      tensor * B;

      char const * alpha;
      char const * beta;
    
      int * idx_A;
      int * idx_B;
      bool is_custom;
      univar_function const * func;

//      summation(){ idx_A = NULL; idx_B = NULL; alpha=NULL; beta=NULL; is_custom=0; };
      
      ~summation();

      summation(summation const & other);

      summation(tensor *     A,
                int const *  idx_A,
                char const * alpha,
                tensor *     B,
                int const *  idx_B,
                char const * beta);
      summation(tensor *     A,
                char const * idx_A,
                char const * alpha,
                tensor *     B,
                char const * idx_B,
                char const * beta);
     
      summation(tensor *                A,
                int const *             idx_A,
                char const *            alpha,
                tensor *                B,
                int const *             idx_B,
                char const *            beta,
                univar_function const * func);
      summation(tensor *                A,
                char const *            idx_A,
                char const *            alpha,
                tensor *                B,
                char const *            idx_B,
                char const *            beta,
                univar_function const * func);

      void execute(bool run_diag=false);
      
      double estimate_time();
   
      int is_equal(summation const & os);


      int sum_tensors(bool run_diag);

      void print();

    private:
      void get_fold_indices(int *  num_fold,
                            int ** fold_idx);
    
      int can_fold();
 
      void get_fold_sum(summation *& fold_sum,
                        int &        all_fdim_A,
                        int &        all_fdim_B,
                        int *&       all_flen_A,
                        int *&       all_flen_B);


      int map_fold();

      double est_time_fold();


      void get_len_ordering(int ** new_ordering_A,
                            int ** new_ordering_B);
  

      tsum * construct_sum(int inner_stride=-1);

      tspsum * construct_sparse_sum(int const * phys_mapped);

      tsum * construct_dense_sum(int         inner_stride,
                                 int const * phys_mapped);


      int home_sum_tsr(bool run_diag);

      int sym_sum_tsr(bool run_diag);

      int unfold_broken_sym(summation ** new_sum);

      bool check_consistency();


      int check_mapping();

      int map_sum_indices(topology const * topo);

      int map();
      
      void sp_sum();
  };
}

#endif