/home/coin/svn-release/OS-2.10.0/OS/src/OSCommonInterfaces/OSGeneral.h

Go to the documentation of this file.

/* $Id: OSGeneral.h 3172 2010-02-05 04:59:24Z Gassmann $ */
#ifndef OSGENERAL_H
#define OSGENERAL_H

#include "OSConfig.h"
#include "OSParameters.h"
#include "OSnLNode.h"
#include "OSExpressionTree.h"

#include <string>
#include <vector>



class GeneralFileHeader
{
public:

    std::string name;

    std::string source;

    std::string description;

    std::string fileCreator;

    std::string licence;


    GeneralFileHeader();

    ~GeneralFileHeader();

    bool IsEqual(GeneralFileHeader *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(GeneralFileHeader *that);

    std::string getHeaderItem(std::string item);

    bool setHeader(std::string name, std::string source, std::string description,
                   std::string fileCreator, std::string licence);

}; //GeneralFileHeader


class SparseVector
{
public:

    SparseVector(int number);

    SparseVector();

    ~SparseVector();

    bool bDeleteArrays;

    int number;

    int* indexes;

    double* values;

}; //SparseVector

class SparseIntVector
{
public:

    SparseIntVector(int number);

    SparseIntVector();

    ~SparseIntVector();

    bool bDeleteArrays;

    int number;

    int* indexes;

    int* values;

}; //SparseIntVector


class SparseMatrix
{
public:
    bool bDeleteArrays;

    bool isColumnMajor;

    int startSize;

    int valueSize;

    int* starts;

    int* indexes;

    double* values;

    SparseMatrix();

    SparseMatrix(bool isColumnMajor_, int startSize, int valueSize);
    ~SparseMatrix();

    bool display(int secondaryDim);

}; //SparseMatrix


class SparseJacobianMatrix
{
public:

    bool bDeleteArrays;

    int startSize;

    int valueSize;

    int* starts;

    int* conVals;

    int* indexes;

    double* values;

    SparseJacobianMatrix();

    SparseJacobianMatrix(int startSize, int valueSize);

    ~SparseJacobianMatrix();

}; //SparseJacobianMatrix



class SparseHessianMatrix
{
public:

    bool bDeleteArrays;

    int hessDimension;

    int* hessRowIdx;

    int* hessColIdx;

    double* hessValues;

    SparseHessianMatrix();

    SparseHessianMatrix(int startSize, int valueSize);

    ~SparseHessianMatrix();

}; //SparseHessianMatrix

class QuadraticTerms
{

public:

    int* rowIndexes;

    int* varOneIndexes;

    int* varTwoIndexes;

    double* coefficients;

    QuadraticTerms();
    ~QuadraticTerms();
}; //QuadraticTerms



class IntVector
{
public:
    IntVector();
    ~IntVector();

    IntVector(int n);

    bool bDeleteArrays;
    int numberOfEl;
    int *el;

    bool IsEqual(IntVector *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(IntVector *that);

    bool setIntVector(int *i, int ni);

    bool extendIntVector(int i);

    int getNumberOfEl();

    int getEl(int j);


    bool getEl(int *i);
};//class IntVector


class OtherOptionOrResultEnumeration : public IntVector
{
public:
    std::string value;
    std::string description;

    OtherOptionOrResultEnumeration();
    ~OtherOptionOrResultEnumeration();

    OtherOptionOrResultEnumeration(int n);

    bool IsEqual(OtherOptionOrResultEnumeration *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(OtherOptionOrResultEnumeration *that);

    bool setOtherOptionOrResultEnumeration(std::string value, std::string description, int *i, int ni);


    std::string getValue();

    std::string getDescription();

};//class OtherOptionOrResultEnumeration


class DoubleVector
{
public:
    DoubleVector();
    ~DoubleVector();

    bool bDeleteArrays;
    int numberOfEl;
    double *el;

    bool IsEqual(DoubleVector *that);
};//class DoubleVector


struct IndexValuePair
{
    int idx;

    double value;
};

class BasisStatus
{
public:
    IntVector* basic;
    IntVector* atLower;
    IntVector* atUpper;
    IntVector* atEquality;
    IntVector* isFree;
    IntVector* superbasic;
    IntVector* unknown;

    BasisStatus();
    ~BasisStatus();

    bool IsEqual(BasisStatus *that);

    bool setRandom(double density, bool conformant, int iMin, int iMax);

    bool deepCopyFrom(BasisStatus *that);

    bool setIntVector(int status, int *i, int ni);

    bool addIdx(int status, int idx);

    int getNumberOfEl(int status);


    int getEl(int status, int j);

    bool getIntVector(int status, int *i);

    int getBasisDense(int *resultArray, int dim, bool flipIdx);
};//class BasisStatus


class StorageCapacity
{

public:
    std::string unit;

    std::string description;

    double value;

    StorageCapacity();
    ~StorageCapacity();

    bool IsEqual(StorageCapacity *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(StorageCapacity *that);
}; //StorageCapacity

class CPUSpeed
{

public:
    std::string unit;

    std::string description;

    double value;

    CPUSpeed();
    ~CPUSpeed();

    bool IsEqual(CPUSpeed *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(CPUSpeed *that);
}; //CPUSpeed

class CPUNumber
{

public:
    std::string description;

    int value;

    CPUNumber();
    ~CPUNumber();

    bool IsEqual(CPUNumber *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(CPUNumber *that);
}; //CPUNumber

class TimeSpan
{

public:
    std::string unit;

    double value;

    TimeSpan();
    ~TimeSpan();

    bool IsEqual(TimeSpan *that);

    bool setRandom(double density, bool conformant);

    bool deepCopyFrom(TimeSpan *that);
}; //TimeSpan


class OSGeneral
{

};


/*************************************************
 *
 * A function to test equality of two doubles.
 * This is needed to check equality of objects
 * when members can have NaN as a possible value
 * since ordinary rules evaluate NaN as different
 * from any other value --- even another NaN
 * We sometimes want (NaN == NaN) to evaluate to true
 *
 *************************************************/
inline bool OSIsEqual(double x, double y)
{
    if (OSIsnan(x) && OSIsnan(y)) return true;
    if (x == y) return true;
    return false;
}


#endif

---