CoinModelUseful.hpp

Go to the documentation of this file.

/* $Id: CoinModelUseful.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CoinModelUseful_H
#define CoinModelUseful_H
 
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <cfloat>
#include <cstring>
#include <cstdio>
#include <iostream>
 
#include "CoinTypes.hpp"
#include "CoinPragma.hpp"
 
 
class CoinModelLink {
 
public:
  CoinModelLink();
  ~CoinModelLink();
 
  CoinModelLink(const CoinModelLink &);
  CoinModelLink &operator=(const CoinModelLink &);
 
  inline int row() const
  {
    return row_;
  }
  inline int column() const
  {
    return column_;
  }
  inline double value() const
  {
    return value_;
  }
  inline double element() const
  {
    return value_;
  }
  inline CoinBigIndex position() const
  {
    return position_;
  }
  inline bool onRow() const
  {
    return onRow_;
  }
  inline void setRow(int row)
  {
    row_ = row;
  }
  inline void setColumn(int column)
  {
    column_ = column;
  }
  inline void setValue(double value)
  {
    value_ = value;
  }
  inline void setElement(double value)
  {
    value_ = value;
  }
  inline void setPosition(CoinBigIndex position)
  {
    position_ = position;
  }
  inline void setOnRow(bool onRow)
  {
    onRow_ = onRow;
  }
 
private:
  int row_;
  int column_;
  double value_;
  CoinBigIndex position_;
  bool onRow_;
};
 
// for specifying triple
typedef struct {
  // top bit is nonzero if string
  // rest is row
  unsigned int row;
  //CoinModelRowIndex row;
  int column;
  double value; // If string then index into strings
} CoinModelTriple;
inline int rowInTriple(const CoinModelTriple &triple)
{
  return triple.row & 0x7fffffff;
}
inline void setRowInTriple(CoinModelTriple &triple, int iRow)
{
  triple.row = iRow | (triple.row & 0x80000000);
}
inline bool stringInTriple(const CoinModelTriple &triple)
{
  return (triple.row & 0x80000000) != 0;
}
inline void setStringInTriple(CoinModelTriple &triple, bool string)
{
  triple.row = (string ? 0x80000000 : 0) | (triple.row & 0x7fffffff);
}
inline void setRowAndStringInTriple(CoinModelTriple &triple,
  int iRow, bool string)
{
  triple.row = (string ? 0x80000000 : 0) | iRow;
}
// for hashing
typedef struct {
  int index, next;
} CoinModelHashLink;
typedef struct {
  CoinBigIndex index, next;
} CoinModelHashLink2;
 
/* Function type.  */
typedef double (*func_t)(double);
 
/* Data type for links in the chain of symbols.  */
struct symrec {
  char *name; /* name of symbol */
  int type; /* type of symbol: either VAR or FNCT */
  union {
    double var; /* value of a VAR */
    func_t fnctptr; /* value of a FNCT */
  } value;
  struct symrec *next; /* link field */
};
 
typedef struct symrec symrec;
 
class CoinYacc {
private:
  CoinYacc(const CoinYacc &rhs);
  CoinYacc &operator=(const CoinYacc &rhs);
 
public:
  CoinYacc()
    : symtable(NULL)
    , symbuf(NULL)
    , length(0)
    , unsetValue(0)
  {
  }
  ~CoinYacc()
  {
    if (length) {
      free(symbuf);
      symbuf = NULL;
    }
    symrec *s = symtable;
    while (s) {
      free(s->name);
      symtable = s;
      s = s->next;
      free(symtable);
    }
  }
 
public:
  symrec *symtable;
  char *symbuf;
  int length;
  double unsetValue;
};
 
class CoinModelHash {
 
public:
  CoinModelHash();
  ~CoinModelHash();
 
  CoinModelHash(const CoinModelHash &);
  CoinModelHash &operator=(const CoinModelHash &);
 
  void resize(int maxItems, bool forceReHash = false);
  inline int numberItems() const
  {
    return numberItems_;
  }
  void setNumberItems(int number);
  inline int maximumItems() const
  {
    return maximumItems_;
  }
  inline const char *const *names() const
  {
    return names_;
  }
 
  int hash(const char *name) const;
  void addHash(int index, const char *name);
  void deleteHash(int index);
  const char *name(int which) const;
  char *getName(int which) const;
  void setName(int which, char *name);
  void validateHash() const;
 
private:
  int hashValue(const char *name) const;
 
public:
private:
  char **names_;
  CoinModelHashLink *hash_;
  int numberItems_;
  int maximumItems_;
  int lastSlot_;
};
class CoinModelHash2 {
 
public:
  CoinModelHash2();
  ~CoinModelHash2();
 
  CoinModelHash2(const CoinModelHash2 &);
  CoinModelHash2 &operator=(const CoinModelHash2 &);
 
  void resize(CoinBigIndex maxItems, const CoinModelTriple *triples, bool forceReHash = false);
  inline CoinBigIndex numberItems() const
  {
    return numberItems_;
  }
  void setNumberItems(CoinBigIndex number);
  inline CoinBigIndex maximumItems() const
  {
    return maximumItems_;
  }
 
  CoinBigIndex hash(int row, int column, const CoinModelTriple *triples) const;
  void addHash(CoinBigIndex index, int row, int column, const CoinModelTriple *triples);
  void deleteHash(CoinBigIndex index, int row, int column);
 
private:
  CoinBigIndex hashValue(int row, int column) const;
 
public:
private:
  CoinModelHashLink2 *hash_;
  CoinBigIndex numberItems_;
  CoinBigIndex maximumItems_;
  CoinBigIndex lastSlot_;
};
class CoinModelLinkedList {
 
public:
  CoinModelLinkedList();
  ~CoinModelLinkedList();
 
  CoinModelLinkedList(const CoinModelLinkedList &);
  CoinModelLinkedList &operator=(const CoinModelLinkedList &);
 
  void resize(int maxMajor, CoinBigIndex maxElements);
  void create(int maxMajor, CoinBigIndex maxElements,
    int numberMajor, int numberMinor,
    int type,
    CoinBigIndex numberElements, const CoinModelTriple *triples);
  inline int numberMajor() const
  {
    return numberMajor_;
  }
  inline int maximumMajor() const
  {
    return maximumMajor_;
  }
  inline CoinBigIndex numberElements() const
  {
    return numberElements_;
  }
  inline CoinBigIndex maximumElements() const
  {
    return maximumElements_;
  }
  inline CoinBigIndex firstFree() const
  {
    return first_[maximumMajor_];
  }
  inline CoinBigIndex lastFree() const
  {
    return last_[maximumMajor_];
  }
  inline CoinBigIndex first(int which) const
  {
    return first_[which];
  }
  inline CoinBigIndex last(int which) const
  {
    return last_[which];
  }
  inline const CoinBigIndex *next() const
  {
    return next_;
  }
  inline const CoinBigIndex *previous() const
  {
    return previous_;
  }
 
  CoinBigIndex addEasy(int majorIndex, CoinBigIndex numberOfElements, const int *indices,
    const double *elements, CoinModelTriple *triples,
    CoinModelHash2 &hash);
  void addHard(int minorIndex, CoinBigIndex numberOfElements, const int *indices,
    const double *elements, CoinModelTriple *triples,
    CoinModelHash2 &hash);
  void addHard(CoinBigIndex first, const CoinModelTriple *triples,
    CoinBigIndex firstFree, CoinBigIndex lastFree, const CoinBigIndex *nextOther);
  void deleteSame(int which, CoinModelTriple *triples,
    CoinModelHash2 &hash, bool zapTriples);
  void updateDeleted(int which, CoinModelTriple *triples,
    CoinModelLinkedList &otherList);
  void deleteRowOne(CoinBigIndex position, CoinModelTriple *triples,
    CoinModelHash2 &hash);
  void updateDeletedOne(CoinBigIndex position, const CoinModelTriple *triples);
  void fill(int first, int last);
  void synchronize(CoinModelLinkedList &other);
  void validateLinks(const CoinModelTriple *triples) const;
private:
  CoinBigIndex *previous_;
  CoinBigIndex *next_;
  CoinBigIndex *first_;
  CoinBigIndex *last_;
  int numberMajor_;
  int maximumMajor_;
  CoinBigIndex numberElements_;
  CoinBigIndex maximumElements_;
  int type_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/