tensor_symbol.hpp

 
#ifndef EXATN_TENSOR_SYMBOL_HPP_
#define EXATN_TENSOR_SYMBOL_HPP_
 
#include "tensor_basic.hpp"
#include "tensor_leg.hpp"
 
#include <string>
#include <vector>
 
namespace exatn{
 
//Index label:
typedef struct{
 std::string label;      //alphanumeric_ index label
 LegDirection direction; //index variance (leg direction)
} IndexLabel;
 
inline bool is_letter(const char & ch){
 return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
}
 
inline bool is_number(const char & ch){
 return (ch >= '0' && ch <= '9');
}
 
inline bool is_underscore(const char & ch){
 return (ch == '_');
}
 
inline bool is_space(const char & ch){
 return (ch == ' ');
}
 
inline bool is_conjugation_sign(const char & ch){
 return (ch == '+');
}
 
inline bool is_equal_sign(const char & ch){
 return (ch == '=');
}
 
inline bool is_plus_sign(const char & ch){
 return (ch == '+');
}
 
inline bool is_minus_sign(const char & ch){
 return (ch == '-');
}
 
inline bool is_multiply_sign(const char & ch){
 return (ch == '*');
}
 
inline bool is_alphanumeric(const std::string & identifier)
{
 if(identifier.empty()) return false;
 if(!is_letter(identifier[0])) return false;
 for(const char & ch: identifier){
  if(!(is_letter(ch) || is_number(ch) || is_underscore(ch))) return false;
 }
 return true;
}
 
inline std::pair<int,int> trim_spaces_off(const std::string & str, //in: full string container
                                          std::pair<int,int> view) //in: input string view
{
 int sbeg = view.first;
 int send = view.second;
 if(sbeg <= send){
  while(send >= sbeg){ //remove trailing white spaces
   if(!is_space(str[send])) break;
   --send;
  }
  while(sbeg <= send){ //remove leading white spaces
   if(!is_space(str[sbeg])) break;
   ++sbeg;
  }
 }
 return std::make_pair(sbeg,send);
}
 
bool parse_tensor(const std::string & tensor,        //in: tensor as a string
                  std::string & tensor_name,         //out: tensor name
                  std::vector<IndexLabel> & indices, //out: tensor indices (labels)
                  bool & complex_conjugated);        //out: whether or not tensor appears complex conjugated
 
bool parse_tensor_network(const std::string & network,         //in: tensor network as a string
                          std::vector<std::string> & tensors); //out: parsed (symbolic) tensors
 
bool generate_contraction_pattern(const std::vector<numerics::TensorLeg> & pattern,
                                  unsigned int left_tensor_rank,
                                  unsigned int right_tensor_rank,
                                  std::string & symb_pattern);
 
} //namespace exatn
 
#endif //EXATN_TENSOR_SYMBOL_HPP_