Algebra.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include <algorithm>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iterator>
#include <map>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
 
#include "MantidGeometry/Math/Algebra.h"
#include "MantidGeometry/Math/MapSupport.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/Strings.h"
 
namespace Mantid::Geometry {
namespace {
Kernel::Logger logger("Algebra");
}
 
std::ostream &operator<<(std::ostream &OX, const Algebra &A)
{
  OX << A.display();
  return OX;
}
 
Algebra::Algebra()
    : F(0)
{}
 
bool Algebra::operator==(const Algebra &A) const
{
  if (this == &A)
    return true;
  return (F == A.F);
}
 
bool Algebra::operator!=(const Algebra &A) const
{
  return (F != A.F);
}
 
Algebra &Algebra::operator+=(const Algebra &M)
{
  F += M.F;
  return *this;
}
 
Algebra &Algebra::operator*=(const Algebra &M)
{
  F *= M.F;
  return *this;
}
 
Algebra Algebra::operator+(const Algebra &M) const
{
  Algebra T(*this);
  T += M;
  return T;
}
 
Algebra Algebra::operator*(const Algebra &M) const
{
  Algebra T(*this);
  T *= M;
  return T;
}
 
void Algebra::Complement()
{
  F.complement();
}
 
std::pair<Algebra, Algebra> Algebra::algDiv(const Algebra &D) const
{
  Algebra Q;
  Algebra R;
  Acomp Tf = F;
  // std::cerr<<"AlgDiv:"<<'\n';
  std::pair<Acomp, Acomp> QR = Tf.algDiv(D.F);
  if (!QR.first.isNull() && !QR.second.isNull()) {
    Q.setFunction(QR.first);
    R.setFunction(QR.second);
  }
  return std::pair<Algebra, Algebra>(Q, R);
}
 
std::string Algebra::writeMCNPX() const
{
  std::string Out = F.display();
  const auto lenOut = static_cast<int>(Out.length());
  Out += " "; // Guard string
  std::ostringstream cx;
  for (int i = 0; i < lenOut; i++) {
    if (islower(Out[i]) || isupper(Out[i])) {
      auto vc =
          find_if(SurfMap.cbegin(), SurfMap.cend(), MapSupport::valEqual<int, std::string>(std::string(1, Out[i])));
      if (vc == SurfMap.end()) {
        logger.error() << "SurfMap size == " << SurfMap.size() << '\n';
        for_each(SurfMap.begin(), SurfMap.end(), MapSupport::mapWrite<int, std::string>());
        throw Kernel::Exception::NotFoundError("Algebra::writeMCNPX", std::string(1, Out[i]));
      }
      if (Out[i + 1] == '\'')
        cx << " -" << vc->first;
      else
        cx << " " << vc->first;
    } else if (Out[i] == '+') {
      cx << " :";
    } else // brackets are constant
    {
      cx << " " << Out[i];
    }
  }
  return cx.str();
}
 
std::ostream &Algebra::write(std::ostream &Out) const
{
  Out << "F == " << F.display() << '\n';
  //  Out<<F.displayDepth(0)<<'\n';
  return Out;
}
 
std::string Algebra::display() const { return F.display(); }
 
int Algebra::setFunctionObjStr(const std::string &A)
{
  // get first item
  std::ostringstream cx;
  std::string nLiteral = "a";
 
  int ipt(0);     // start of component
  int bigFlag(0); // Literals getting big
  while (ipt < static_cast<int>(A.length())) {
 
    if (A[ipt] == '(' || A[ipt] == ')') {
      cx << A[ipt];
      ipt++;
    } else if (A[ipt] == '-' || isdigit(A[ipt])) {
      int N;
      int nCount = Mantid::Kernel::Strings::convPartNum(A.substr(ipt, std::string::npos), N);
      if (nCount) {
        int neg(0);
        if (N < 0) {
          N *= -1;
          neg = 1;
        }
        auto mc = SurfMap.find(N);
        if (mc == SurfMap.end()) {
          if (!bigFlag) {
            SurfMap[N] = nLiteral;
            cx << nLiteral;
            nLiteral[0] = (nLiteral[0] == 'z') ? 'A' : static_cast<char>(static_cast<int>(nLiteral[0]) + 1);
            bigFlag = (nLiteral[0] == 'Z') ? 1 : 0;
          } else {
            std::ostringstream lcx;
            lcx << "%" << bigFlag;
            SurfMap[N] = lcx.str();
            cx << lcx.str();
            bigFlag++;
          }
        } else {
          cx << mc->second;
        }
        // Add negation note:
        if (neg)
          cx << "\'";
        // Add to the number
        ipt += nCount;
      } else {
        throw std::invalid_argument("Algebra::setFunction: ncount==0");
      }
    } else if (A[ipt] == ':') {
      cx << "+";
      ipt++;
    } else if (A[ipt] == '#') {
      cx << "#";
      ipt++;
    } else // Space
      ipt++;
  }
  setFunction(cx.str());
  return 0;
}
 
int Algebra::setFunction(const std::string &A)
{
  // Get copy
  std::string Ln = A;
  // Strip spaces.
  std::string::size_type pos;
  while ((pos = Ln.find(' ')) != std::string::npos)
    Ln.erase(pos, 1);
  try {
    F.setString(Ln);
  } catch (...) {
    logger.error() << "Algebra String Error" << A << '\n';
    return 1;
  }
  return 0;
}
 
int Algebra::setFunction(const Acomp &A)
{
  F = A;
  return 0;
}
 
int Algebra::countLiterals() const
{
  std::map<int, int> Lit;
  F.getLiterals(Lit);
  return static_cast<int>(Lit.size());
}
 
int Algebra::logicalEqual(const Algebra &A) const
{
  return F.logicalEqual(A.F);
}
 
} // namespace Mantid::Geometry