BasisFunction.cc

Go to the documentation of this file.

#include "casm/basis_set/BasisFunction.hh"
 
#include "casm/basis_set/BasisSet.hh"
#include "casm/casm_io/json/jsonParser.hh"
 
namespace CASM {
 
Index Function::ID_count(0);
Array<Array<InnerProduct *> > Function::inner_prod_table =
    Array<Array<InnerProduct *> >();
Array<Array<FunctionOperation *> > Function::operation_table =
    Array<Array<FunctionOperation *> >();
 
//*******************************************************************************************
 
Function::Function(const std::vector<std::shared_ptr<BasisSet> > &_args)
    : func_ID(ID_count++), m_argument(_args) {
  // Index linear_ind(0);
  for (Index i = 0; i < m_argument.size(); i++) {
    for (Index j = 0; j < m_argument[i]->size(); j++) {
      m_arg2sub.push_back(i);
      m_arg2fun.push_back(j);
    }
  }
}
//*******************************************************************************************
 
double Function::dot(Function const *RHS) const {
  return inner_prod_table[this->class_ID()][RHS->class_ID()]->dot(this, RHS);
}
 
//*******************************************************************************************
void Function::normalize() {
  double mag(sqrt(this->dot(this)));
  if (almost_zero(mag)) {
    return;
  }
  m_formula.clear();
  m_tex_formula.clear();
  this->scale(1.0 / mag);
}
 
//*******************************************************************************************
 
bool Function::shallow_compare(Function const *RHS) const {
  return (operation_table[this->class_ID()][RHS->class_ID()])
      ->compare(this, RHS);
}
 
//*******************************************************************************************
 
bool Function::compare(Function const *RHS) const {
  if (m_argument.size() != (RHS->m_argument).size()) return false;
 
  // if operations between this and RHS are undefined, return false
  if (!operation_table[this->class_ID()][RHS->class_ID()]) return false;
 
  for (Index i = 0; i < m_argument.size(); i++) {
    if (!(m_argument[i]->compare(*(RHS->m_argument)[i]))) return false;
  }
 
  return shallow_compare(RHS);
}
 
//*******************************************************************************************
 
Function *Function::plus(Function const *RHS) const {
  return operation_table[this->class_ID()][RHS->class_ID()]->add(this, RHS);
}
//*******************************************************************************************
 
Function *Function::minus(Function const *RHS) const {
  return operation_table[this->class_ID()][RHS->class_ID()]->subtract(this,
                                                                      RHS);
}
//*******************************************************************************************
 
Function *Function::poly_quotient(Function const *RHS) const {
  return operation_table[this->class_ID()][RHS->class_ID()]->poly_quotient(this,
                                                                           RHS);
}
//*******************************************************************************************
 
Function *Function::poly_remainder(Function const *RHS) const {
  return operation_table[this->class_ID()][RHS->class_ID()]->poly_remainder(
      this, RHS);
}
//*******************************************************************************************
 
Function *Function::multiply(Function const *RHS) const {
  return (operation_table[this->class_ID()][RHS->class_ID()])
      ->multiply(this, RHS);
}
//*******************************************************************************************
 
Function *Function::plus_in_place(Function const *RHS) {
  m_formula.clear();
  m_tex_formula.clear();
  refresh_ID();
  return operation_table[this->class_ID()][RHS->class_ID()]->add_to(this, RHS);
}
//*******************************************************************************************
 
Function *Function::minus_in_place(Function const *RHS) {
  m_formula.clear();
  m_tex_formula.clear();
  refresh_ID();
  return operation_table[this->class_ID()][RHS->class_ID()]->subtract_from(this,
                                                                           RHS);
}
 
//*******************************************************************************************
void Function::set_arguments(const ArgumentContainer &new_arg,
                             std::vector<Index> const &compatibility_map) {
  _set_arguments(new_arg, compatibility_map);
 
  m_arg2sub.clear();
  m_arg2fun.clear();
  for (Index i = 0; i < new_arg.size(); i++) {
    for (Index j = 0; j < new_arg[i]->size(); j++) {
      m_arg2sub.push_back(i);
      m_arg2fun.push_back(j);
    }
  }
}
//*******************************************************************************************
 
ReturnArray<SymGroupRepID> Function::_sub_sym_reps() const {
  Array<SymGroupRepID> t_result(m_argument.size());
  for (Index i = 0; i < m_argument.size(); i++) {
    t_result[i] = m_argument[i]->basis_symrep_ID();
  }
  return t_result;
}
 
//*******************************************************************************************
 
Function const *Function::_argument(Index i) const {
  return (*m_argument[m_arg2sub[i]])[m_arg2fun[i]];
}
 
//*******************************************************************************************
 
double Function::_arg_eval_cache(Index i) const {
  return m_argument[m_arg2sub[i]]->eval_cache(m_arg2fun[i]);
}
 
//*******************************************************************************************
 
double Function::_arg_deval_cache(Index i) const {
  return m_argument[m_arg2sub[i]]->deval_cache(m_arg2fun[i]);
}
 
//*******************************************************************************************
 
int Function::_dependency_layer() const {
  int tdep = -1;
  for (Index i = 0; i < m_argument.size(); i++) {
    tdep = max(tdep, m_argument[i]->dependency_layer());
  }
  return ++tdep;
}
//*******************************************************************************************
/*
  Function *Function::_argument(Index i) {
  return (*m_argument[m_arg2sub[i]])[m_arg2fun[i]];
  }
*/
//*******************************************************************************************
 
bool Function::accept(const FunctionVisitor &visitor,
                      BasisSet const *home_basis_ptr) {
  // bool is_updated(false);
  // std::cout << "INSIDE BASE Function::accept\n";
  // shared_basis
  // for(Index i = 0; i < m_argument.size(); i++)
  // is_updated = (m_argument[i]->accept(visitor)) || is_updated; // should we
  // add && depends_on to first part?
 
  // if(is_updated) {
  // m_formula.clear();
  // m_tex_formula.clear();
  //}
  return _accept(visitor, home_basis_ptr);  // || is_updated;
}
 
//*******************************************************************************************
 
bool Function::accept(const FunctionVisitor &visitor,
                      BasisSet const *home_basis_ptr) const {
  // bool is_updated(false);
  // std::cout << "INSIDE BASE Function::accept\n";
  // shared_basis
  // for(Index i = 0; i < m_argument.size(); i++)
  // is_updated = (m_argument[i]->accept(visitor)) || is_updated; // should we
  // add && depends_on to first part?
 
  // if(is_updated) {
  // m_formula.clear();
  // m_tex_formula.clear();
  //}
  return _accept(visitor, home_basis_ptr);  // || is_updated;
}
 
//*******************************************************************************************
 
void Function::refresh_ID() { func_ID = ID_count++; }
 
//*******************************************************************************************
 
void Function::print(std::ostream &stream) const {
  if (!m_formula.size()) {
    this->make_formula();
  }
  stream << m_formula;
  return;
}
//*******************************************************************************************
 
void Function::print_tex(std::ostream &stream) const {
  if (!m_formula.size()) {
    this->make_formula();
  }
  stream << m_tex_formula;
  return;
}
 
//*******************************************************************************************
 
Function *Function::sym_copy_coeffs(const SymOp &op,
                                    int dependency_level) const {
  Function *tptr(this->copy());
  return tptr->apply_sym_coeffs(op, dependency_level);
}
 
//*******************************************************************************************
 
int Function::register_remotes(
    const std::vector<DoF::RemoteHandle> &remote_handles) {
  int t_tot(0);
  // From now on, this will be handled at BasisSet level
  // for(Index i = 0; i < m_argument.size(); i++) {
  // t_tot += m_argument[i]->register_remotes(dof_name, remote_handles);
  //}
  return t_tot;
}
 
//*******************************************************************************************
 
bool Function::update_dof_IDs(const std::vector<Index> &before_IDs,
                              const std::vector<Index> &after_IDs) {
  // JCT shared_basis
  /*bool is_updated(false);
  for(Index i = 0; i < m_argument.size(); i++) {
    is_updated = ((m_argument[i]->update_dof_IDs(before_IDs, after_IDs)) &&
  depends_on(m_argument[i])) || is_updated;
  }
 
  if(is_updated) {
    m_formula.clear();
    m_tex_formula.clear();
  }
  */
  return _update_dof_IDs(before_IDs, after_IDs);
}
 
//*******************************************************************************************
void Function::set_identifier(char _key, std::string const &_value) {
  m_identifiers[_key] = _value;
}
 
//*******************************************************************************************
std::string Function::identifier(char _key) const {
  auto it = m_identifiers.find(_key);
  if (it == m_identifiers.end()) return "?";
  return it->second;
}
 
//*******************************************************************************************
 
std::string Function::formula() const {
  if (!m_formula.size()) {
    this->make_formula();
  }
 
  return m_formula;
}
 
//*******************************************************************************************
 
std::string Function::tex_formula() const {
  if (!m_formula.size()) {
    this->make_formula();
  }
 
  return m_tex_formula;
}
 
//*******************************************************************************************
 
// Comparison
bool FunctionOperation::compare(Function const *LHS,
                                Function const *RHS) const {
  // default behavior if Functions are of different types
  return false;
}
 
//*******************************************************************************************
 
// Multiplication (tensor product)
Function *FunctionOperation::multiply(Function const *LHS,
                                      Function const *RHS) const {
  std::cerr << "WARNING: Multiplication of type " << LHS->type_name()
            << " with type " << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
Function *FunctionOperation::multiply_by(Function *LHS,
                                         Function const *RHS) const {
  std::cerr << "WARNING: Multiplication of type " << LHS->type_name()
            << " with type " << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
// Addition
Function *FunctionOperation::add(Function const *LHS,
                                 Function const *RHS) const {
  std::cerr << "WARNING: Addition of type " << LHS->type_name() << " with type "
            << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
Function *FunctionOperation::add_to(Function *LHS, Function const *RHS) const {
  std::cerr << "WARNING: Addition of type " << LHS->type_name() << " with type "
            << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
// Subtraction
Function *FunctionOperation::subtract(Function const *LHS,
                                      Function const *RHS) const {
  std::cerr << "WARNING: Subtraction of type " << LHS->type_name()
            << " with type " << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
Function *FunctionOperation::subtract_from(Function *LHS,
                                           Function const *RHS) const {
  std::cerr << "WARNING: Subtraction of type " << LHS->type_name()
            << " with type " << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
// Polynomial division
Function *FunctionOperation::poly_quotient(Function const *LHS,
                                           Function const *RHS) const {
  std::cerr << "WARNING: Polynomial division of type " << LHS->type_name()
            << " with type " << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
 
Function *FunctionOperation::poly_remainder(Function const *LHS,
                                            Function const *RHS) const {
  std::cerr << "WARNING: Polynomial division of type " << LHS->type_name()
            << " with type " << RHS->type_name() << " is undefined!!!\n";
  return nullptr;
}
 
//*******************************************************************************************
//** jsonParser stuff - Function
//*******************************************************************************************
 
jsonParser &Function::to_json(jsonParser &json) const {
  // Not quite sure what to do with all this.  For now, just print 'formula'.
 
  //  static members:
  //
  // class Function : public HierarchyID<Function>
  //   static int Nclass;
  // static int ID_count;
  // static Array< Array< InnerProduct * > > inner_prod_table;
  // static Array< Array< TensorProduct * > > tensor_prod_table;
  // static Array< Array< FunctionDifference * > > difference_table;
  // static Array< Array< FunctionSum * > > sum_table;
 
  // int func_ID;
  // Array<Function *> m_argument;
  // mutable std::string m_formula, m_tex_formula;
 
  json.put_obj();
 
  json["m_formula"] = m_formula;
 
  return json;
}
 
//*******************************************************************************************
 
/*
void Function::from_json(const jsonParser &json) {
 
  // no reading functions for now
 
}
*/
 
//*******************************************************************************************
 
jsonParser &to_json(const Function *func, jsonParser &json) {
  return func->to_json(json);
}
 
// This does not exist: void from_json(Function *func, const jsonParser &json);
// Use the json (i.e. json["Function_type"] = "MonomialFunction")
//   to know which Function's from_json to call
 
}  // namespace CASM