Added libalm.so and its dependency liblinprog.so. libalm.so provides a
BLayout implementation (BALMLayout) using the Auckland Layout Model (ALM). The original ALM was implemented by Christof Lutteroth, the Haiku/C++ version by James Kim. The code needs some review, but the test programs seem to work fine. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@23889 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold
@@ -0,0 +1,149 @@
|
||||
#ifndef AREA_H
|
||||
#define AREA_H
|
||||
|
||||
#include "Constraint.h"
|
||||
#include "SoftConstraint.h"
|
||||
|
||||
#include <Alignment.h>
|
||||
#include <List.h>
|
||||
#include <Size.h>
|
||||
#include <SupportDefs.h>
|
||||
#include <View.h>
|
||||
|
||||
|
||||
namespace BALM {
|
||||
|
||||
class Column;
|
||||
class BALMLayout;
|
||||
class Row;
|
||||
class XTab;
|
||||
class YTab;
|
||||
|
||||
/**
|
||||
* Rectangular area in the GUI, defined by a tab on each side.
|
||||
*/
|
||||
class Area {
|
||||
|
||||
public:
|
||||
bool AutoPrefContentSize() const;
|
||||
void SetAutoPrefContentSize(bool value);
|
||||
XTab* Left() const;
|
||||
void SetLeft(XTab* left);
|
||||
XTab* Right() const;
|
||||
void SetRight(XTab* right);
|
||||
YTab* Top() const;
|
||||
void SetTop(YTab* top);
|
||||
YTab* Bottom() const;
|
||||
void SetBottom(YTab* bottom);
|
||||
Row* GetRow() const;
|
||||
void SetRow(Row* row);
|
||||
Column* GetColumn() const;
|
||||
void SetColumn(Column* column);
|
||||
BView* Content() const;
|
||||
void SetContent(BView* content);
|
||||
XTab* ContentLeft() const;
|
||||
YTab* ContentTop() const;
|
||||
XTab* ContentRight() const;
|
||||
YTab* ContentBottom() const;
|
||||
BSize MinContentSize() const;
|
||||
void SetMinContentSize(BSize min);
|
||||
BSize MaxContentSize() const;
|
||||
void SetMaxContentSize(BSize max);
|
||||
BSize PrefContentSize() const;
|
||||
void SetPrefContentSize(BSize pref);
|
||||
BSize ShrinkRigidity() const;
|
||||
void SetShrinkRigidity(BSize shrink);
|
||||
BSize ExpandRigidity() const;
|
||||
void SetExpandRigidity(BSize expand);
|
||||
double ContentAspectRatio() const;
|
||||
void SetContentAspectRatio(double ratio);
|
||||
BAlignment Alignment() const;
|
||||
void SetAlignment(BAlignment alignment);
|
||||
void SetHAlignment(alignment horizontal);
|
||||
void SetVAlignment(vertical_alignment vertical);
|
||||
int32 LeftInset() const;
|
||||
void SetLeftInset(int32 left);
|
||||
int32 TopInset() const;
|
||||
void SetTopInset(int32 top);
|
||||
int32 RightInset() const;
|
||||
void SetRightInset(int32 right);
|
||||
int32 BottomInset() const;
|
||||
void SetBottomInset(int32 bottom);
|
||||
void SetDefaultPrefContentSize();
|
||||
//~ string ToString();
|
||||
Constraint* HasSameWidthAs(Area* area);
|
||||
Constraint* HasSameHeightAs(Area* area);
|
||||
BList* HasSameSizetAs(Area* area);
|
||||
~Area();
|
||||
|
||||
protected:
|
||||
Area(BALMLayout* ls, XTab* left, YTab* top,
|
||||
XTab* right, YTab* bottom,
|
||||
BView* content,
|
||||
BSize minContentSize);
|
||||
Area(BALMLayout* ls, Row* row, Column* column,
|
||||
BView* content,
|
||||
BSize minContentSize);
|
||||
void DoLayout();
|
||||
|
||||
private:
|
||||
void InitChildArea();
|
||||
void UpdateHorizontal();
|
||||
void UpdateVertical();
|
||||
void Init(BALMLayout* ls, XTab* left, YTab* top,
|
||||
XTab* right, YTab* bottom,
|
||||
BView* content,
|
||||
BSize minContentSize);
|
||||
|
||||
public:
|
||||
static BSize kMaxSize;
|
||||
static BSize kMinSize;
|
||||
static BSize kUndefinedSize;
|
||||
|
||||
protected:
|
||||
BView* fContent;
|
||||
BList* fConstraints;
|
||||
|
||||
private:
|
||||
BALMLayout* fLS;
|
||||
XTab* fLeft;
|
||||
XTab* fRight;
|
||||
YTab* fTop;
|
||||
YTab* fBottom;
|
||||
Row* fRow;
|
||||
Column* fColumn;
|
||||
BSize fMinContentSize;
|
||||
BSize fMaxContentSize;
|
||||
Constraint* fMinContentWidth;
|
||||
Constraint* fMaxContentWidth;
|
||||
Constraint* fMinContentHeight;
|
||||
Constraint* fMaxContentHeight;
|
||||
BSize fPrefContentSize;
|
||||
BSize fShrinkRigidity;
|
||||
BSize fExpandRigidity;
|
||||
double fContentAspectRatio;
|
||||
Constraint* fContentAspectRatioC;
|
||||
bool fAutoPrefContentSize;
|
||||
SoftConstraint* fPrefContentWidth;
|
||||
SoftConstraint* fPrefContentHeight;
|
||||
Area* fChildArea;
|
||||
BAlignment fAlignment;
|
||||
int32 fLeftInset;
|
||||
int32 fTopInset;
|
||||
int32 fRightInset;
|
||||
int32 fBottomInset;
|
||||
Constraint* fLeftConstraint;
|
||||
Constraint* fTopConstraint;
|
||||
Constraint* fRightConstraint;
|
||||
Constraint* fBottomConstraint;
|
||||
|
||||
public:
|
||||
friend class BALMLayout;
|
||||
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::Area;
|
||||
|
||||
#endif // AREA_H
|
||||
@@ -0,0 +1,106 @@
|
||||
#ifndef BALM_LAYOUT_H
|
||||
#define BALM_LAYOUT_H
|
||||
|
||||
#include <File.h>
|
||||
#include <Layout.h>
|
||||
#include <List.h>
|
||||
#include <Size.h>
|
||||
#include <SupportDefs.h>
|
||||
#include <View.h>
|
||||
|
||||
#include "LayoutStyleType.h"
|
||||
#include "LinearSpec.h"
|
||||
|
||||
|
||||
namespace BALM {
|
||||
|
||||
class Area;
|
||||
class Column;
|
||||
class Row;
|
||||
class XTab;
|
||||
class YTab;
|
||||
|
||||
/**
|
||||
* A GUI layout engine using the ALM.
|
||||
*/
|
||||
class BALMLayout : public BLayout, public LinearSpec {
|
||||
|
||||
public:
|
||||
BALMLayout();
|
||||
void SolveLayout();
|
||||
|
||||
XTab* AddXTab();
|
||||
YTab* AddYTab();
|
||||
Row* AddRow();
|
||||
Row* AddRow(YTab* top, YTab* bottom);
|
||||
Column* AddColumn();
|
||||
Column* AddColumn(XTab* left, XTab* right);
|
||||
Area* AddArea(XTab* left, YTab* top, XTab* right, YTab* bottom,
|
||||
BView* content, BSize minContentSize);
|
||||
Area* AddArea(Row* row, Column* column, BView* content,
|
||||
BSize minContentSize);
|
||||
Area* AddArea(XTab* left, YTab* top, XTab* right, YTab* bottom,
|
||||
BView* content);
|
||||
Area* AddArea(Row* row, Column* column, BView* content);
|
||||
Area* AreaOf(BView* control);
|
||||
BList* Areas() const;
|
||||
void SetAreas(BList* areas);
|
||||
XTab* Left() const;
|
||||
void SetLeft(XTab* left);
|
||||
XTab* Right() const;
|
||||
void SetRight(XTab* right);
|
||||
YTab* Top() const;
|
||||
void SetTop(YTab* top);
|
||||
YTab* Bottom() const;
|
||||
void SetBottom(YTab* bottom);
|
||||
|
||||
void RecoverLayout(BView* parent);
|
||||
LayoutStyleType LayoutStyle() const;
|
||||
void SetLayoutStyle(LayoutStyleType style);
|
||||
|
||||
BLayoutItem* AddView(BView* child);
|
||||
BLayoutItem* AddView(int32 index, BView* child);
|
||||
bool AddItem(BLayoutItem* item);
|
||||
bool AddItem(int32 index, BLayoutItem* item);
|
||||
bool RemoveView(BView* child);
|
||||
bool RemoveItem(BLayoutItem* item);
|
||||
BLayoutItem* RemoveItem(int32 index);
|
||||
|
||||
BSize MinSize();
|
||||
BSize MaxSize();
|
||||
BSize PreferredSize();
|
||||
BAlignment Alignment();
|
||||
bool HasHeightForWidth();
|
||||
void GetHeightForWidth(float width, float* min,
|
||||
float* max, float* preferred);
|
||||
void InvalidateLayout();
|
||||
void LayoutView();
|
||||
|
||||
char* PerformancePath() const;
|
||||
void SetPerformancePath(char* path);
|
||||
|
||||
private:
|
||||
BSize CalculateMinSize();
|
||||
BSize CalculateMaxSize();
|
||||
BSize CalculatePreferredSize();
|
||||
|
||||
private:
|
||||
LayoutStyleType fLayoutStyle;
|
||||
bool fActivated;
|
||||
|
||||
BList* fAreas;
|
||||
XTab* fLeft;
|
||||
XTab* fRight;
|
||||
YTab* fTop;
|
||||
YTab* fBottom;
|
||||
BSize fMinSize;
|
||||
BSize fMaxSize;
|
||||
BSize fPreferredSize;
|
||||
char* fPerformancePath;
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::BALMLayout;
|
||||
|
||||
#endif // BALM_LAYOUT_H
|
||||
@@ -0,0 +1,58 @@
|
||||
#ifndef COLUMN_H
|
||||
#define COLUMN_H
|
||||
|
||||
#include "Constraint.h"
|
||||
|
||||
#include <List.h>
|
||||
|
||||
|
||||
namespace BALM {
|
||||
|
||||
class BALMLayout;
|
||||
class XTab;
|
||||
|
||||
/**
|
||||
* Represents a column defined by two x-tabs.
|
||||
*/
|
||||
class Column {
|
||||
|
||||
public:
|
||||
XTab* Left() const;
|
||||
XTab* Right() const;
|
||||
Column* Previous() const;
|
||||
void SetPrevious(Column* value);
|
||||
Column* Next() const;
|
||||
void SetNext(Column* value);
|
||||
//~ string ToString();
|
||||
void InsertBefore(Column* column);
|
||||
void InsertAfter(Column* column);
|
||||
Constraint* HasSameWidthAs(Column* column);
|
||||
BList* Constraints() const;
|
||||
void SetConstraints(BList* constraints);
|
||||
~Column();
|
||||
|
||||
protected:
|
||||
Column(BALMLayout* ls);
|
||||
|
||||
protected:
|
||||
BALMLayout* fLS;
|
||||
XTab* fLeft;
|
||||
XTab* fRight;
|
||||
|
||||
private:
|
||||
Column* fPrevious;
|
||||
Column* fNext;
|
||||
Constraint* fPreviousGlue;
|
||||
Constraint* fNextGlue;
|
||||
BList* fConstraints;
|
||||
|
||||
public:
|
||||
friend class BALMLayout;
|
||||
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::Column;
|
||||
|
||||
#endif // COLUMN_H
|
||||
@@ -0,0 +1,20 @@
|
||||
#ifndef LAYOUT_STYLE_TYPE_H
|
||||
#define LAYOUT_STYLE_TYPE_H
|
||||
|
||||
|
||||
namespace BALM {
|
||||
|
||||
/**
|
||||
* The possibilities for adjusting a GUI's layout.
|
||||
* Either change the child controls so that they fit into their parent control, or adjust
|
||||
* the size of the parent control so that the children have as much space as they want.
|
||||
*/
|
||||
enum LayoutStyleType {
|
||||
FIT_TO_SIZE, ADJUST_SIZE
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::LayoutStyleType;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,58 @@
|
||||
#ifndef ROW_H
|
||||
#define ROW_H
|
||||
|
||||
#include "Constraint.h"
|
||||
|
||||
#include <List.h>
|
||||
|
||||
|
||||
namespace BALM {
|
||||
|
||||
class BALMLayout;
|
||||
class YTab;
|
||||
|
||||
/**
|
||||
* Represents a row defined by two y-tabs.
|
||||
*/
|
||||
class Row {
|
||||
|
||||
public:
|
||||
YTab* Top() const;
|
||||
YTab* Bottom() const;
|
||||
Row* Previous() const;
|
||||
void SetPrevious(Row* value);
|
||||
Row* Next() const;
|
||||
void SetNext(Row* value);
|
||||
//~ string ToString();
|
||||
void InsertBefore(Row* row);
|
||||
void InsertAfter(Row* row);
|
||||
Constraint* HasSameHeightAs(Row* row);
|
||||
BList* Constraints() const;
|
||||
void SetConstraints(BList* constraints);
|
||||
~Row();
|
||||
|
||||
protected:
|
||||
Row(BALMLayout* ls);
|
||||
|
||||
protected:
|
||||
BALMLayout* fLS;
|
||||
YTab* fTop;
|
||||
YTab* fBottom;
|
||||
|
||||
private:
|
||||
Row* fPrevious;
|
||||
Row* fNext;
|
||||
Constraint* fPreviousGlue;
|
||||
Constraint* fNextGlue;
|
||||
BList* fConstraints;
|
||||
|
||||
public:
|
||||
friend class BALMLayout;
|
||||
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::Row;
|
||||
|
||||
#endif // ROW_H
|
||||
@@ -0,0 +1,38 @@
|
||||
#ifndef X_TAB_H
|
||||
#define X_TAB_H
|
||||
|
||||
#include "Variable.h"
|
||||
|
||||
|
||||
namespace BALM {
|
||||
|
||||
class BALMLayout;
|
||||
|
||||
/**
|
||||
* Vertical grid line (x-tab).
|
||||
*/
|
||||
class XTab : public Variable {
|
||||
|
||||
protected:
|
||||
XTab(BALMLayout* ls);
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Property signifying if there is a constraint which relates
|
||||
* this tab to a different tab that is further to the left.
|
||||
* Only used for reverse engineering.
|
||||
*/
|
||||
bool fLeftLink;
|
||||
|
||||
public:
|
||||
friend class Area;
|
||||
friend class Column;
|
||||
friend class BALMLayout;
|
||||
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::XTab;
|
||||
|
||||
#endif // X_TAB_H
|
||||
@@ -0,0 +1,37 @@
|
||||
#ifndef Y_TAB_H
|
||||
#define Y_TAB_H
|
||||
|
||||
#include "Variable.h"
|
||||
|
||||
namespace BALM {
|
||||
|
||||
class BALMLayout;
|
||||
|
||||
/**
|
||||
* Horizontal grid line (y-tab).
|
||||
*/
|
||||
class YTab : public Variable {
|
||||
|
||||
protected:
|
||||
YTab(BALMLayout* ls);
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Property signifying if there is a constraint which relates
|
||||
* this tab to a different tab that is further to the top.
|
||||
* Only used for reverse engineering.
|
||||
*/
|
||||
bool fTopLink;
|
||||
|
||||
public:
|
||||
friend class Area;
|
||||
friend class Row;
|
||||
friend class BALMLayout;
|
||||
|
||||
};
|
||||
|
||||
} // namespace BALM
|
||||
|
||||
using BALM::YTab;
|
||||
|
||||
#endif // Y_TAB_H
|
||||
@@ -0,0 +1,56 @@
|
||||
#ifndef CONSTRAINT_H
|
||||
#define CONSTRAINT_H
|
||||
|
||||
#include "OperatorType.h"
|
||||
|
||||
#include <List.h>
|
||||
#include <String.h>
|
||||
#include <SupportDefs.h>
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
class LinearSpec;
|
||||
|
||||
/**
|
||||
* Hard linear constraint, i.e. one that must be satisfied.
|
||||
* May render a specification infeasible.
|
||||
*/
|
||||
class Constraint {
|
||||
|
||||
public:
|
||||
int32 Index();
|
||||
BList* Coeffs();
|
||||
BList* Vars();
|
||||
virtual void ChangeLeftSide(BList* coeffs, BList* vars);
|
||||
virtual OperatorType Op();
|
||||
virtual void SetOp(OperatorType value);
|
||||
double RightSide();
|
||||
void SetRightSide(double value);
|
||||
BString ToString();
|
||||
virtual ~Constraint();
|
||||
|
||||
protected:
|
||||
Constraint();
|
||||
|
||||
private:
|
||||
Constraint(LinearSpec* ls, BList* coeffs, BList* vars,
|
||||
OperatorType op, double rightSide);
|
||||
|
||||
protected:
|
||||
LinearSpec* fLS;
|
||||
BList* fCoeffs;
|
||||
BList* fVars;
|
||||
OperatorType fOp;
|
||||
double fRightSide;
|
||||
|
||||
public:
|
||||
friend class LinearSpec;
|
||||
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::Constraint;
|
||||
|
||||
#endif // CONSTRAINT_H
|
||||
@@ -0,0 +1,124 @@
|
||||
#ifndef LINEAR_SPEC_H
|
||||
#define LINEAR_SPEC_H
|
||||
|
||||
#include "OperatorType.h"
|
||||
#include "ResultType.h"
|
||||
#include "OptimizationType.h"
|
||||
|
||||
#include "lp_lib.h"
|
||||
|
||||
#include <List.h>
|
||||
#include <OS.h>
|
||||
#include <SupportDefs.h>
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
class Constraint;
|
||||
class ObjFunctionSummand;
|
||||
class PenaltyFunction;
|
||||
class SoftConstraint;
|
||||
class Variable;
|
||||
|
||||
/**
|
||||
* Specification of a linear programming problem.
|
||||
*/
|
||||
class LinearSpec {
|
||||
|
||||
public:
|
||||
LinearSpec();
|
||||
~LinearSpec();
|
||||
void UpdateObjFunction();
|
||||
void SetObjFunction(BList* coeffs, BList* vars);
|
||||
ObjFunctionSummand* AddObjFunctionSummand(double coeff, Variable* var);
|
||||
Variable* AddVariable();
|
||||
|
||||
Constraint* AddConstraint(BList* coeffs, BList* vars,
|
||||
OperatorType op, double rightSide);
|
||||
Constraint* AddConstraint(double coeff1, Variable* var1,
|
||||
OperatorType op, double rightSide);
|
||||
Constraint* AddConstraint(double coeff1, Variable* var1,
|
||||
double coeff2, Variable* var2,
|
||||
OperatorType op, double rightSide);
|
||||
Constraint* AddConstraint(double coeff1, Variable* var1,
|
||||
double coeff2, Variable* var2,
|
||||
double coeff3, Variable* var3,
|
||||
OperatorType op, double rightSide);
|
||||
Constraint* AddConstraint(double coeff1, Variable* var1,
|
||||
double coeff2, Variable* var2,
|
||||
double coeff3, Variable* var3,
|
||||
double coeff4, Variable* var4,
|
||||
OperatorType op, double rightSide);
|
||||
|
||||
SoftConstraint* AddSoftConstraint(BList* coeffs, BList* vars,
|
||||
OperatorType op, double rightSide,
|
||||
double penaltyNeg, double penaltyPos);
|
||||
SoftConstraint* AddSoftConstraint(double coeff1, Variable* var1,
|
||||
OperatorType op, double rightSide,
|
||||
double penaltyNeg, double penaltyPos);
|
||||
SoftConstraint* AddSoftConstraint(double coeff1, Variable* var1,
|
||||
double coeff2, Variable* var2,
|
||||
OperatorType op, double rightSide,
|
||||
double penaltyNeg, double penaltyPos);
|
||||
SoftConstraint* AddSoftConstraint(double coeff1, Variable* var1,
|
||||
double coeff2, Variable* var2,
|
||||
double coeff3, Variable* var3,
|
||||
OperatorType op, double rightSide,
|
||||
double penaltyNeg, double penaltyPos);
|
||||
SoftConstraint* AddSoftConstraint(double coeff1, Variable* var1,
|
||||
double coeff2, Variable* var2,
|
||||
double coeff3, Variable* var3,
|
||||
double coeff4, Variable* var4,
|
||||
OperatorType op, double rightSide,
|
||||
double penaltyNeg, double penaltyPos);
|
||||
|
||||
PenaltyFunction* AddPenaltyFunction(Variable* var, BList* xs, BList* gs);
|
||||
void RemovePresolved();
|
||||
ResultType Presolve();
|
||||
ResultType Solve();
|
||||
void Save(char* fname);
|
||||
|
||||
int32 Columns() const;
|
||||
void SetColumns(int32 value);
|
||||
OptimizationType Optimization() const;
|
||||
void SetOptimization(OptimizationType value);
|
||||
lprec* LP() const;
|
||||
void SetLP(lprec* value);
|
||||
BList* ObjFunctionSummands() const;
|
||||
void SetObjFunctionSummands(BList* value);
|
||||
BList* Variables() const;
|
||||
void SetVariables(BList* value);
|
||||
BList* Constraints() const;
|
||||
void SetConstraints(BList* value);
|
||||
ResultType Result() const;
|
||||
void SetResult(ResultType value);
|
||||
double ObjectiveValue() const;
|
||||
void SetObjectiveValue(double value);
|
||||
double SolvingTime() const;
|
||||
void SetSolvingTime(double value);
|
||||
|
||||
protected:
|
||||
int32 fColumns;
|
||||
|
||||
private:
|
||||
lprec* fLpPresolved;
|
||||
OptimizationType fOptimization;
|
||||
lprec* fLP;
|
||||
BList* fObjFunctionSummands;
|
||||
BList* fVariables;
|
||||
BList* fConstraints;
|
||||
ResultType fResult;
|
||||
double fObjectiveValue;
|
||||
double fSolvingTime; // = Double.Nan
|
||||
|
||||
public:
|
||||
friend class ObjFunctionSummand;
|
||||
friend class SoftConstraint;
|
||||
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::LinearSpec;
|
||||
|
||||
#endif // LINEAR_SPEC_H
|
||||
@@ -0,0 +1,39 @@
|
||||
#ifndef OBJ_FUNCTION_SUMMAND_H
|
||||
#define OBJ_FUNCTION_SUMMAND_H
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
class LinearSpec;
|
||||
class Variable;
|
||||
|
||||
/**
|
||||
* A summand of the objective function.
|
||||
*/
|
||||
class ObjFunctionSummand {
|
||||
|
||||
public:
|
||||
double Coeff();
|
||||
void SetCoeff(double coeff);
|
||||
Variable* Var();
|
||||
void SetVar(Variable* var);
|
||||
~ObjFunctionSummand();
|
||||
|
||||
protected:
|
||||
ObjFunctionSummand(LinearSpec* ls, double coeff, Variable* var);
|
||||
|
||||
private:
|
||||
LinearSpec* fLS;
|
||||
double fCoeff;
|
||||
Variable* fVar;
|
||||
|
||||
public:
|
||||
friend class LinearSpec;
|
||||
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::ObjFunctionSummand;
|
||||
|
||||
#endif // OBJ_FUNCTION_SUMMAND_H
|
||||
@@ -0,0 +1,18 @@
|
||||
#ifndef OPERATOR_TYPE_H
|
||||
#define OPERATOR_TYPE_H
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
/**
|
||||
* Possible operators for linear constraints.
|
||||
*/
|
||||
enum OperatorType {
|
||||
EQ, LE, GE
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::OperatorType;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,18 @@
|
||||
#ifndef OPTIMIZATION_TYPE_H
|
||||
#define OPTIMIZATION_TYPE_H
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
/**
|
||||
* The two possibilities for optimizing the objective function.
|
||||
*/
|
||||
enum OptimizationType {
|
||||
MINIMIZE, MAXIMIZE
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::OptimizationType;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
#ifndef PENALTY_FUNCTION_H
|
||||
#define PENALTY_FUNCTION_H
|
||||
|
||||
#include <List.h>
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
class LinearSpec;
|
||||
class Variable;
|
||||
|
||||
/**
|
||||
* Penalty function.
|
||||
*/
|
||||
class PenaltyFunction {
|
||||
|
||||
protected:
|
||||
PenaltyFunction(LinearSpec* ls, Variable* var, BList* xs, BList* gs);
|
||||
|
||||
public:
|
||||
~PenaltyFunction();
|
||||
const Variable* Var() const;
|
||||
const BList* Xs() const;
|
||||
const BList* Gs() const;
|
||||
|
||||
private:
|
||||
LinearSpec* fLS;
|
||||
Variable* fVar;
|
||||
BList* fXs; // double
|
||||
BList* fGs; // double
|
||||
BList* fConstraints;
|
||||
BList* fObjFunctionSummands;
|
||||
|
||||
public:
|
||||
friend class LinearSpec;
|
||||
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::PenaltyFunction;
|
||||
|
||||
#endif // PENALTY_FUNCTION_H
|
||||
@@ -0,0 +1,20 @@
|
||||
#ifndef RESULT_TYPE_H
|
||||
#define RESULT_TYPE_H
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
/**
|
||||
* The possible results of a solving attempt.
|
||||
*/
|
||||
enum ResultType {
|
||||
NOMEMORY = -2, ERROR = -1, OPTIMAL = 0, SUBOPTIMAL = 1, INFEASIBLE = 2, UNBOUNDED = 3,
|
||||
DEGENERATE = 4, NUMFAILURE = 5, USERABORT = 6, TIMEOUT = 7, PRESOLVED = 9, PROCFAIL = 10,
|
||||
PROCBREAK = 11, FEASFOUND = 12, NOFEASFOUND = 13
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::ResultType;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,54 @@
|
||||
#ifndef SOFT_CONSTRAINT_H
|
||||
#define SOFT_CONSTRAINT_H
|
||||
|
||||
#include "Constraint.h"
|
||||
|
||||
#include <List.h>
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
class LinearSpec;
|
||||
class ObjFunctionSummand;
|
||||
class Variable;
|
||||
|
||||
/**
|
||||
* Soft constraint, i.e. one that does not necessarily have to be satisfied.
|
||||
* Use this instead of hard constraints to avoid over-constrained specifications.
|
||||
*/
|
||||
class SoftConstraint : public Constraint {
|
||||
|
||||
public:
|
||||
void ChangeLeftSide(BList* coeffs, BList* vars);
|
||||
OperatorType Op();
|
||||
void SetOp(OperatorType value);
|
||||
double PenaltyNeg();
|
||||
void SetPenaltyNeg(double value);
|
||||
double PenaltyPos();
|
||||
void SetPenaltyPos(double value);
|
||||
//~ string ToString();
|
||||
Variable* DNeg() const;
|
||||
Variable* DPos() const;
|
||||
~SoftConstraint();
|
||||
|
||||
protected:
|
||||
SoftConstraint(LinearSpec* ls, BList* coeffs, BList* vars,
|
||||
OperatorType op, double rightSide,
|
||||
double penaltyNeg, double penaltyPos);
|
||||
|
||||
private:
|
||||
Variable* fDNeg;
|
||||
Variable* fDPos;
|
||||
ObjFunctionSummand* fDNegSummand;
|
||||
ObjFunctionSummand* fDPosSummand;
|
||||
|
||||
public:
|
||||
friend class LinearSpec;
|
||||
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::SoftConstraint;
|
||||
|
||||
#endif // SOFT_CONSTRAINT_H
|
||||
@@ -0,0 +1,53 @@
|
||||
#ifndef VARIABLE_H
|
||||
#define VARIABLE_H
|
||||
|
||||
#include <SupportDefs.h>
|
||||
|
||||
|
||||
namespace LinearProgramming {
|
||||
|
||||
class Constraint;
|
||||
class LinearSpec;
|
||||
|
||||
/**
|
||||
* Contains minimum and maximum values.
|
||||
*/
|
||||
class Variable {
|
||||
|
||||
public:
|
||||
int32 Index();
|
||||
LinearSpec* LS() const;
|
||||
void SetLS(LinearSpec* value);
|
||||
double Value() const;
|
||||
void SetValue(double value);
|
||||
double Min() const;
|
||||
void SetMin(double min);
|
||||
double Max() const;
|
||||
void SetMax(double max);
|
||||
void SetRange(double min, double max);
|
||||
//~ string ToString();
|
||||
Constraint* IsEqual(Variable* var);
|
||||
Constraint* IsSmallerOrEqual(Variable* var);
|
||||
Constraint* IsGreaterorEqual(Variable* var);
|
||||
|
||||
protected:
|
||||
Variable(LinearSpec* ls);
|
||||
~Variable();
|
||||
|
||||
private:
|
||||
LinearSpec* fLS;
|
||||
double fValue;
|
||||
double fMin;
|
||||
double fMax;
|
||||
|
||||
public:
|
||||
friend class LinearSpec;
|
||||
friend class SoftConstraint;
|
||||
|
||||
};
|
||||
|
||||
} // namespace LinearProgramming
|
||||
|
||||
using LinearProgramming::Variable;
|
||||
|
||||
#endif // VARIABLE_H
|
||||
Reference in New Issue
Block a user