constant_sx.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *
 *    CasADi is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_CONSTANT_SX_HPP
#define CASADI_CONSTANT_SX_HPP
 
#include "sx_node.hpp"
#include "serializing_stream.hpp"
#include "matrix_decl.hpp"
#include <cassert>
 
 
// Cashing of constants requires a map
#include <unordered_map>
#define CACHING_MAP std::unordered_map
 
namespace casadi {
 
class ConstantSX : public SXNode {
public:
 
// Destructor
~ConstantSX() override {}
 
// Class name
std::string class_name() const override {return "ConstantSX";}
 
double to_double() const override = 0;
 
bool is_constant() const override { return true; }
 
casadi_int op() const override { return OP_CONST;}
 
bool is_value(double v) const override {
  return casadi_limits<double>::is_value(to_double(), v);
}
bool is_half() const override { return casadi_limits<double>::is_half(to_double()); }
bool is_integer() const override { return casadi_limits<double>::is_integer(to_double()); }
 
bool is_equal(const SXNode* node, casadi_int depth) const override {
  const ConstantSX* n = dynamic_cast<const ConstantSX*>(node);
  return n && n->to_double()==to_double();
}
 
protected:
 
std::string print(const std::string& arg1, const std::string& arg2) const override {
   std::stringstream ss;
   ss.precision(Matrix<SXElem>::get_precision());
   ss.width(Matrix<SXElem>::get_width());
   if (Matrix<SXElem>::get_scientific()) {
     ss.setf(std::ios::scientific);
   } else {
     ss.unsetf(std::ios::scientific);
   }
   ss << to_double();
   return ss.str();
 }
 
};
 
class RealtypeSX : public ConstantSX {
  private:
    explicit RealtypeSX(double value) : value(value) {}
 
  public:
 
    ~RealtypeSX() override {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    // Safe access to cached_constants_
    std::lock_guard<std::mutex> lock(mutex_cached_constants);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      size_t num_erased = cached_constants_.erase(value);
      assert(num_erased==1);
      (void)num_erased;
    }
 
    inline static RealtypeSX* create(double value) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    // Safe access to cached_constants_
    std::lock_guard<std::mutex> lock(mutex_cached_constants);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      // Try to find the constant
      CACHING_MAP<double, RealtypeSX*>::iterator it = cached_constants_.find(value);
 
      // If not found, add it,
      if (it==cached_constants_.end()) {
        // Allocate a new object
        RealtypeSX* n = new RealtypeSX(value);
 
        // Add to hash_table
        cached_constants_.insert(it, std::make_pair(value, n));
 
        // Return it to caller
        return n;
      } else { // Else, returned the object
        return it->second;
      }
    }
 
 
    double to_double() const override { return value;}
    casadi_int to_int() const override { return static_cast<casadi_int>(value);}
 
    bool is_almost_zero(double tol) const override { return fabs(value)<=tol; }
 
    void serialize_node(SerializingStream& s) const override {
      s.pack("ConstantSX::type", 'r');
      s.pack("ConstantSX::value", value);
    }
 
  protected:
    static CACHING_MAP<double, RealtypeSX*> cached_constants_;
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    static std::mutex mutex_cached_constants;
#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
 
    double value;
};
 
 
class IntegerSX : public ConstantSX {
  private:
    explicit IntegerSX(casadi_int value) : value(static_cast<int>(value)) {
      casadi_assert(value<=std::numeric_limits<int>::max() &&
                    value>=std::numeric_limits<int>::min(), "Integer overflow");
    }
 
  public:
 
    ~IntegerSX() override {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    // Safe access to cached_constants_
    std::lock_guard<std::mutex> lock(mutex_cached_constants);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      size_t num_erased = cached_constants_.erase(value);
      assert(num_erased==1);
      (void)num_erased;
    }
 
    inline static IntegerSX* create(casadi_int value) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    // Safe access to cached_constants_
    std::lock_guard<std::mutex> lock(mutex_cached_constants);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      // Try to find the constant
      CACHING_MAP<casadi_int, IntegerSX*>::iterator it = cached_constants_.find(value);
 
      // If not found, add it,
      if (it==cached_constants_.end()) {
        // Allocate a new object
        IntegerSX* n = new IntegerSX(value);
 
        // Add to hash_table
        cached_constants_.insert(it, std::make_pair(value, n));
 
        // Return it to caller
        return n;
      } else { // Else, returned the object
        return it->second;
      }
    }
 
 
    double to_double() const override {  return static_cast<double>(value); }
    casadi_int to_int() const override {  return static_cast<casadi_int>(value); }
 
    bool is_integer() const override { return true; }
 
    void serialize_node(SerializingStream& s) const override {
      s.pack("ConstantSX::type", 'i');
      s.pack("ConstantSX::value", value);
    }
 
  protected:
 
    static CACHING_MAP<casadi_int, IntegerSX*> cached_constants_;
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    static std::mutex mutex_cached_constants;
#endif //CASADI_WITH_THREADSAFE_SYMBOLICS
 
    int value;
};
 
class ZeroSX : public ConstantSX {
private:
  /* Private constructor (singleton class) */
  explicit ZeroSX() {this->count++;}
public:
  /* Get singleton instance */
  static ZeroSX* singleton() {
    static ZeroSX instance;
    return &instance;
  }
  /* Destructor */
  ~ZeroSX() override {this->count--;}
 
  double to_double() const override { return 0;}
  casadi_int to_int() const override { return 0;}
 
 
  bool is_integer() const override { return true; }
  bool is_zero() const override { return true; }
  bool is_almost_zero(double tol) const override { return true; }
 
  void serialize_node(SerializingStream& s) const override {
    s.pack("ConstantSX::type", '0');
  }
};
 
 
class OneSX : public ConstantSX {
private:
  /* Private constructor (singleton class) */
  explicit OneSX() {this->count++;}
public:
  /* Get singleton instance */
  static OneSX* singleton() {
    static OneSX instance;
    return &instance;
  }
  /* Destructor */
  ~OneSX() override {this->count--;}
  double to_double() const override { return 1;}
  casadi_int to_int() const override { return 1;}
 
  bool is_integer() const override { return true; }
  bool is_one() const override { return true; }
 
  void serialize_node(SerializingStream& s) const override {
    s.pack("ConstantSX::type", '1');
  }
 
};
 
 
class MinusOneSX : public ConstantSX {
private:
  /* Private constructor (singleton class) */
  explicit MinusOneSX() {this->count++;}
public:
  /* Get singleton instance */
  static MinusOneSX* singleton() {
    static MinusOneSX instance;
    return &instance;
  }
  /* Destructor */
  ~MinusOneSX() override {this->count--;}
 
 
  double to_double() const override { return -1;}
  casadi_int to_int() const override { return -1;}
 
 
  bool is_integer() const override { return true; }
  bool is_minus_one() const override { return true; }
 
  void serialize_node(SerializingStream& s) const override {
    s.pack("ConstantSX::type", 'm');
  }
 
};
 
 
class InfSX : public ConstantSX {
private:
  /* Private constructor (singleton class) */
  explicit InfSX() {this->count++;}
public:
  /* Get singleton instance */
  static InfSX* singleton() {
    static InfSX instance;
    return &instance;
  }
  /* Destructor */
  ~InfSX() override {this->count--;}
  double to_double() const override { return std::numeric_limits<double>::infinity();}
 
  bool is_inf() const override { return true; }
 
  void serialize_node(SerializingStream& s) const override {
    s.pack("ConstantSX::type", 'F');
  }
 
};
 
 
class MinusInfSX : public ConstantSX {
private:
  /* Private constructor (singleton class) */
  explicit MinusInfSX() {this->count++;}
public:
  /* Get singleton instance */
  static MinusInfSX* singleton() {
    static MinusInfSX instance;
    return &instance;
  }
  /* Destructor */
  ~MinusInfSX() override {this->count--;}
 
  double to_double() const override { return -std::numeric_limits<double>::infinity();}
 
  bool is_minus_inf() const override { return true; }
 
  void serialize_node(SerializingStream& s) const override {
    s.pack("ConstantSX::type", 'f');
  }
};
 
class NanSX : public ConstantSX {
private:
  /* Private constructor (singleton class) */
  explicit NanSX() {this->count++;}
public:
  /* Get singleton instance */
  static NanSX* singleton() {
    static NanSX instance;
    return &instance;
  }
  /* Destructor */
  ~NanSX() override {this->count--;}
  double to_double() const override { return std::numeric_limits<double>::quiet_NaN();}
 
  bool is_nan() const override { return true; }
 
  void serialize_node(SerializingStream& s) const override {
    s.pack("ConstantSX::type", 'n');
  }
 
};
 
inline SXNode* ConstantSX_deserialize(DeserializingStream& s) {
  char type;
  s.unpack("ConstantSX::type", type);
  switch (type) {
    case '1': return casadi_limits<SXElem>::one.get();
    case '0': return casadi_limits<SXElem>::zero.get();
    case 'r': {
      double value;
      s.unpack("ConstantSX::value", value);
      return RealtypeSX::create(value);
    }
    case 'i': {
      int value;
      s.unpack("ConstantSX::value", value);
      if (value==2) return casadi_limits<SXElem>::two.get();
      return IntegerSX::create(value);
    }
    case 'n': return casadi_limits<SXElem>::nan.get();
    case 'f': return casadi_limits<SXElem>::minus_inf.get();
    case 'F': return casadi_limits<SXElem>::inf.get();
    case 'm': return casadi_limits<SXElem>::minus_one.get();
    default: casadi_error("ConstantSX::deserialize error");
  }
}
 
} // namespace casadi
 
#endif // CASADI_CONSTANT_SX_HPP