/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinModelUseful.hpp

Go to the documentation of this file.

// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinModelUseful_H
#define CoinModelUseful_H


#include <cmath>
#include <cassert>
#include <cfloat>
#include <cstring>
#include <cstdio>
#include <iostream>


#include "CoinPragma.hpp"
#include "CoinFinite.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 {
  unsigned int string:1; // nonzero if string
  unsigned int row:31;
  //CoinModelRowIndex row;
  int column;
  double value; // If string then index into strings
} CoinModelTriple;

// 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;

typedef struct {
  symrec * symtable;
  char * symbuf;
  int length;
  double unsetValue;
} CoinYacc;
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_;
};
inline char * CoinStrdup(const char * name)
{ return (name ) ? strdup(name) : NULL;}

#endif

---