CoinModelUseful.hpp

Go to the documentation of this file.

/* $Id: CoinModelUseful.hpp 1416 2011-04-17 09:57:29Z stefan $ */
// 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 "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 int 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(int position)
  { position_=position;}
  inline void setOnRow(bool onRow)
  { onRow_=onRow;}

private:
  int row_;
  int column_;
  double value_;
  int 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;

/* 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(int maxItems, const CoinModelTriple * triples,bool forceReHash=false);
  inline int numberItems() const
  { return numberItems_;}
  void setNumberItems(int number);
  inline int maximumItems() const
  { return maximumItems_;}

  int hash(int row, int column, const CoinModelTriple * triples) const;
  void addHash(int index, int row, int column, const CoinModelTriple * triples);
  void deleteHash(int index, int row, int column);
private:
  int hashValue(int row, int column) const;
public:
private:
  CoinModelHashLink * hash_;
  int numberItems_;
  int maximumItems_;
  int lastSlot_;
};
class CoinModelLinkedList {
  
public:
  CoinModelLinkedList();
  ~CoinModelLinkedList();
  
  CoinModelLinkedList(const CoinModelLinkedList&);
  CoinModelLinkedList& operator=(const CoinModelLinkedList&);

  void resize(int maxMajor,int maxElements);
  void create(int maxMajor,int maxElements,
              int numberMajor, int numberMinor,
              int type,
              int numberElements, const CoinModelTriple * triples);
  inline int numberMajor() const
  { return numberMajor_;}
  inline int maximumMajor() const
  { return maximumMajor_;}
  inline int numberElements() const
  { return numberElements_;}
  inline int maximumElements() const
  { return maximumElements_;}
  inline int firstFree() const
  { return first_[maximumMajor_];}
  inline int lastFree() const
  { return last_[maximumMajor_];}
  inline int first(int which) const
  { return first_[which];}
  inline int last(int which) const
  { return last_[which];}
  inline const int * next() const
  { return next_;}
  inline const int * previous() const
  { return previous_;}

  int addEasy(int majorIndex, int numberOfElements, const int * indices,
              const double * elements, CoinModelTriple * triples,
              CoinModelHash2 & hash);
  void addHard(int minorIndex, int numberOfElements, const int * indices,
               const double * elements, CoinModelTriple * triples,
               CoinModelHash2 & hash);
  void addHard(int first, const CoinModelTriple * triples,
               int firstFree, int lastFree,const int * nextOther);
  void deleteSame(int which, CoinModelTriple * triples,
                 CoinModelHash2 & hash, bool zapTriples);
  void updateDeleted(int which, CoinModelTriple * triples,
                     CoinModelLinkedList & otherList);
  void deleteRowOne(int position, CoinModelTriple * triples,
                 CoinModelHash2 & hash);
  void updateDeletedOne(int position, const CoinModelTriple * triples);
  void fill(int first,int last);
  void synchronize(CoinModelLinkedList & other);
  void validateLinks(const CoinModelTriple * triples) const;
private:
  int * previous_;
  int * next_;
  int * first_;
  int * last_;
  int numberMajor_;
  int maximumMajor_;
  int numberElements_;
  int maximumElements_;
  int type_;
};

#endif