/// <summary>
/// Solves this model.
/// </summary>
public void Solve()
{
// Init
LogLine("Solving ...");
DateTime before = DateTime.Now;
LinearModel model = new LinearModel(SolverType.Gurobi, (string msg) => { Log(msg); });
VariableCollection <int> xVar = new VariableCollection <int>(model, VariableType.Continuous, 0, double.PositiveInfinity, (int j) => { return("x" + j.ToString()); });
// Modify some control parameters
foreach (var param in _solverArgs)
{
model.SetParam(param.Key, param.Value);
}
// Prepare non-zero indices
Dictionary <int, List <int> > nnzs = _coefficientMatrix.Keys.GroupBy(k => (int)k[0]).ToDictionary(k => k.Key, v => v.Select(e => (int)e[1]).ToList());
// Add objective
model.SetObjective(
LinearExpression.Sum(
Enumerable.Range(0, N).Select(j => _objCoeffcientVector[j]),
Enumerable.Range(0, N).Select(j => xVar[j])),
OptimizationSense.Minimize);
// Add constraint
foreach (var i in nnzs.Keys)
{
model.AddConstr(LinearExpression.Sum(
nnzs[i].Select(j => _coefficientMatrix[i, j]),
nnzs[i].Select(j => xVar[j]))
== _rhsVector[i],
"Con" + i);
}
// TODO remove debug
model.Update();
model.ExportMPS("mdp.mps");
// Solve
model.Optimize();
TimeSpan solutionTime = DateTime.Now - before;
// Get solution
if (model.HasSolution())
{
LogLine("Solution found!");
_solutionVector = Enumerable.Range(0, N).Select(j => xVar[j].Value).ToList();
_solutionValue = model.GetObjectiveValue();
SolutionAvailable = true;
}
else
{
LogLine("No solution!");
}
// Log performance
LogPerformance(before, Filename, solutionTime, SolutionAvailable, _solutionValue, _solverArgs.Select(a => a.Key + "=" + a.Value));
}
public Expression Transform(Expression expr)
{
if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
IList <Expression> arguments = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
arguments.Add(Transform(arg));
}
return(Expression.Function(fexpr.Name, arguments));
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Expression left = Transform(bexpr.Left);
Expression right = Transform(bexpr.Right);
if (bexpr.Operator == Binary.Divide || bexpr.Operator == Binary.Power)
{
return(Expression.FromBinary(bexpr.Operator, left, right));
}
else
{
LinearExpression linear = new LinearExpression(bexpr.Operator);
linear.Insert(left);
linear.Insert(right);
return(linear);
}
}
else if (expr is LinearExpression)
{
LinearExpression lexpr = (LinearExpression)expr;
IList <Expression> list = new List <Expression>();
foreach (Expression item in lexpr.List)
{
list.Add(Transform(item));
}
return(new LinearExpression(lexpr.Operator, list));
}
return(expr);
}
public static bool Equals(Expression left, Expression right)
{
if (!left.GetType().Equals(right.GetType()))
{
return(false);
}
if (left is BinaryExpression)
{
BinaryExpression bleft = (BinaryExpression)left;
BinaryExpression bright = (BinaryExpression)right;
return(bleft.Operator == bright.Operator && Equals(bleft.Left, bright.Left) && Equals(bleft.Right, bright.Right));
}
else if (left is LinearExpression)
{
LinearExpression lleft = (LinearExpression)left;
LinearExpression lright = (LinearExpression)right;
bool eq = lleft.Operator == lright.Operator && lleft.List.Count == lright.List.Count;
if (eq == false)
{
return(false);
}
for (int i = 0; i < lleft.List.Count; i++)
{
eq = eq && Equals(lleft[i], lright[i]);
}
return(eq);
}
else if (left is NumberExpression)
{
return(equalsNumber((NumberExpression)left, (NumberExpression)right));
}
else if (left is VariableExpression)
{
return(equalsVariable((VariableExpression)left, (VariableExpression)right));
}
else if (left is FunctionExpression)
{
return(equalsFunction((FunctionExpression)left, (FunctionExpression)right));
}
return(false);
}
public Expression Transform(Expression expr)
{
if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
IList <Expression> arguments = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
arguments.Add(Transform(arg));
}
return(Expression.Function(fexpr.Name, arguments));
}
else if (expr is LinearExpression)
{
LinearExpression lexpr = (LinearExpression)expr;
if (lexpr.List.Count == 0)
{
throw new Exception("Can't transform an empty linear tree");
}
Expression first = Transform(lexpr[0]);
lexpr.List.RemoveAt(0);
List <Expression> rest = (List <Expression>)lexpr.List;
foreach (Expression e in rest)
{
first = Expression.FromBinary(lexpr.Operator, first, Transform(e));
}
return(first);
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Expression left = Transform(bexpr.Left);
Expression right = Transform(bexpr.Right);
return(Expression.FromBinary(bexpr.Operator, left, right));
}
return(expr);
}
public Vector2?IntersectionPoint(Line other)
{
LinearExpression a = new LinearExpression(this);
LinearExpression b = new LinearExpression(other);
Vector2? intersection = a.IntersectionPoint(b);
if (intersection.HasValue)
{
if (intersection.Value.X > A.X && intersection.Value.X < B.X &&
intersection.Value.Y > A.Y && intersection.Value.Y < B.Y)
{
return(intersection.Value);
}
}
return(null);
}
public static bool Contains(Expression expr, Expression sub)
{
if (expr.GetType().Equals(sub.GetType()))
{
return(expr.Equals(sub));
}
if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
return(Contains(bexpr.Left, sub) && Contains(bexpr.Right, sub));
}
else if (expr is LinearExpression)
{
LinearExpression lexpr = (LinearExpression)expr;
bool contains = true;
foreach (Expression item in lexpr.List)
{
contains = contains && Contains(item, sub);
}
return(contains);
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
bool contains = true;
foreach (Expression arg in fexpr.Arguments)
{
contains = contains && Contains(arg, sub);
}
return(contains);
}
return(false);
}
/// <summary>
/// Transforms the object-model into a mathematical formulation
/// </summary>
/// <returns>The model</returns>
internal override LinearModel Transform()
{
// Init
LinearModel model = new LinearModel(ChosenSolver, Config.Log);
double bigMSideLengthOverall = Instance.Containers.Max(c => Math.Max(Math.Max(c.Mesh.Length, c.Mesh.Width), c.Mesh.Height));
Dictionary <int, double> bigMSideLength = new Dictionary <int, double>()
{
{ _betas[0], Instance.Containers.Max(c => c.Mesh.Length) }, { _betas[1], Instance.Containers.Max(c => c.Mesh.Width) }, { _betas[2], Instance.Containers.Max(c => c.Mesh.Height) }
};
double slantBigM =
Instance.Containers.Max(c => Math.Sqrt(Math.Pow(c.Mesh.Length, 2) + Math.Pow(c.Mesh.Width, 2) + Math.Pow(c.Mesh.Height, 2))) /
Instance.Containers.Min(c => Math.Sqrt(Math.Pow(c.Mesh.Length, 2) + Math.Pow(c.Mesh.Width, 2) + Math.Pow(c.Mesh.Height, 2)));
// --> Variables
_itemIsPicked = new VariableCollection <Piece, Container>(model, VariableType.Integer, 0, 1, (Piece piece, Container container) => { return("ItemPicked" + piece.ToIdentString() + container.ToIdentString()); });
_containerUsed = new VariableCollection <Container>(model, VariableType.Integer, 0, 1, (Container container) => { return("ContainerUsed" + container.ToIdentString()); });
_itemOrientation = new VariableCollection <int, Piece>(model, VariableType.Integer, 0, 1, (int orientation, Piece piece) => { return("ItemOrientation" + piece.ToIdentString() + "O" + orientation); });
_localReferenceFrameOrigin = new VariableCollection <int, Piece>(model, VariableType.Continuous, 0, double.PositiveInfinity, (int beta, Piece piece) => { return("LocalReferenceFrameOrigin" + piece.ToIdentString() + "B" + beta); });
_vertexPosition = new VariableCollection <int, int, MeshCube, Piece>(model, VariableType.Continuous, 0, double.PositiveInfinity, (int beta, int vertexID, MeshCube cube, Piece piece) => { return("VertexPosition" + piece.ToIdentString() + cube.ToIdentString() + "VID" + vertexID + "Beta" + beta); });
_lambda = new VariableCollection <Container, int, int, MeshCube, Piece>(model, VariableType.Continuous, 0, double.PositiveInfinity, (Container container, int gamma, int vertexID, MeshCube cube, Piece piece) => { return("Lambda" + container.ToIdentString() + piece.ToIdentString() + cube.ToIdentString() + "VID" + vertexID + "Gamma" + gamma); });
_sigmaPlus = new VariableCollection <int, MeshCube, MeshCube, Piece, Piece>(model, VariableType.Integer, 0, 1, (int beta, MeshCube cube1, MeshCube cube2, Piece piece1, Piece piece2) => { return("SigmaPlus" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString() + "Beta" + beta); });
_sigmaMinus = new VariableCollection <int, MeshCube, MeshCube, Piece, Piece>(model, VariableType.Integer, 0, 1, (int beta, MeshCube cube1, MeshCube cube2, Piece piece1, Piece piece2) => { return("SigmaMinus" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString() + "Beta" + beta); });
_locatedOnGround = new VariableCollection <Piece>(model, VariableType.Integer, 0, 1, (Piece cluster) => { return("LocatedOnGround" + cluster.ToIdentString()); });
_locatedOn = new VariableCollection <MeshCube, MeshCube, Piece, Piece>(model, VariableType.Integer, 0, 1, (MeshCube cube1, MeshCube cube2, Piece piece1, Piece piece2) => { return("LocatedOn" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString()); });
_bothInContainer = new VariableCollection <Container, Piece, Piece>(model, VariableType.Integer, 0, 1, (Container container, Piece piece1, Piece piece2) => { return("BothInContainer" + container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString()); });
// Keep model up-to-date
model.Update();
// --> Objective
switch (Config.Goal)
{
case OptimizationGoal.MinContainer:
{
// Minimize container count
model.SetObjective(
LinearExpression.Sum(Instance.Containers.Select(container => _containerUsed[container])),
OptimizationSense.Minimize);
}
break;
case OptimizationGoal.MaxUtilization:
{
// Maximize utilization
model.SetObjective(
LinearExpression.Sum(Instance.Containers.Select(container =>
LinearExpression.Sum(Instance.Pieces.Select(piece =>
_itemIsPicked[piece, container] * piece.Volume)))),
OptimizationSense.Maximize);
}
break;
default:
break;
}
// --> Constraints
// Container usage
foreach (var container in Instance.Containers)
{
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
_itemIsPicked[piece, container] <= _containerUsed[container],
"ContainerActivity" + container.ToIdentString() + piece.ToIdentString());
}
}
// Orthogonality constraints
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
(Config.Goal == OptimizationGoal.MaxUtilization) ?
LinearExpression.Sum(Instance.Containers.Select(container => _itemIsPicked[piece, container])) <= 1 :
LinearExpression.Sum(Instance.Containers.Select(container => _itemIsPicked[piece, container])) == 1,
"ItemSingularity" + piece.ToIdentString());
}
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
LinearExpression.Sum(MeshConstants.ORIENTATIONS.Select(orientation => _itemOrientation[orientation, piece])) ==
LinearExpression.Sum(Instance.Containers.Select(container => _itemIsPicked[piece, container])),
"UseOneOrientationPerItem" + piece.ToIdentString());
}
foreach (var beta in _betas)
{
foreach (var piece in Instance.Pieces)
{
foreach (var cube in piece.Original.Components)
{
foreach (var vertexID in MeshConstants.VERTEX_IDS)
{
model.AddConstr(
_vertexPosition[beta, vertexID, cube, piece]
== _localReferenceFrameOrigin[beta, piece]
+ LinearExpression.Sum(
MeshConstants.ORIENTATIONS.Select(orientation =>
piece[orientation][cube.ID][vertexID][beta] * _itemOrientation[orientation, piece])),
"LinkVerticesToLocalReferenceFrame" + piece.ToIdentString() + cube.ToIdentString() + "VID" + vertexID + "Beta" + beta);
}
}
}
}
// Domain constraints
foreach (var beta in _betas)
{
foreach (var piece in Instance.Pieces)
{
foreach (var cube in piece.Original.Components)
{
foreach (var vertexID in MeshConstants.VERTEX_IDS.Skip(1))
{
model.AddConstr(
_vertexPosition[beta, vertexID, cube, piece]
==
LinearExpression.Sum(Instance.Containers.Select(container =>
LinearExpression.Sum(MeshConstants.VERTEX_IDS.Skip(1).Select(gamma =>
container.Mesh[gamma][beta] *
_lambda[container, gamma, vertexID, cube, piece])))),
"Domain1" + piece.ToIdentString() + cube.ToIdentString() + "VID" + vertexID + "Beta" + beta);
}
}
}
}
foreach (var piece in Instance.Pieces)
{
foreach (var cube in piece.Original.Components)
{
foreach (var vertexID in MeshConstants.VERTEX_IDS.Skip(1))
{
foreach (var container in Instance.Containers)
{
model.AddConstr(
LinearExpression.Sum(MeshConstants.VERTEX_IDS.Skip(1).Select(gamma =>
_lambda[container, gamma, vertexID, cube, piece]))
== _itemIsPicked[piece, container],
"Domain2" + container.ToIdentString() + piece.ToIdentString() + cube.ToIdentString() + "VID" + vertexID);
}
}
}
}
// Non-intersection
HashSet <Piece> seenPieces = new HashSet <Piece>();
foreach (var piece1 in Instance.PiecesWithVirtuals.OrderBy(p => p.ID))
{
seenPieces.Add(piece1);
foreach (var piece2 in Instance.PiecesWithVirtuals.OrderBy(p => p.ID).Except(seenPieces))
{
foreach (var cube1 in piece1.Original.Components.OrderBy(c => c.ID))
{
foreach (var cube2 in piece2.Original.Components.OrderBy(c => c.ID))
{
foreach (var beta in _betas)
{
model.AddConstr(
_vertexPosition[beta, 0, cube1, piece1]
- _vertexPosition[beta, 0, cube2, piece2]
>=
(0.5 *
LinearExpression.Sum(MeshConstants.ORIENTATIONS.Select(orientation =>
piece1[orientation][cube1.ID].SideLength(beta) * _itemOrientation[orientation, piece1]
+
piece2[orientation][cube2.ID].SideLength(beta) * _itemOrientation[orientation, piece2])))
-
(bigMSideLength[beta] * (1 - _sigmaPlus[beta, cube1, cube2, piece1, piece2]))
,
"NonOverlapPos" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString() + "Beta" + beta);
model.AddConstr(
_vertexPosition[beta, 0, cube2, piece2]
- _vertexPosition[beta, 0, cube1, piece1]
>=
(0.5 *
LinearExpression.Sum(MeshConstants.ORIENTATIONS.Select(orientation =>
piece1[orientation][cube1.ID].SideLength(beta) * _itemOrientation[orientation, piece1]
+
piece2[orientation][cube2.ID].SideLength(beta) * _itemOrientation[orientation, piece2])))
-
(bigMSideLength[beta] * (1 - _sigmaMinus[beta, cube1, cube2, piece1, piece2]))
,
"NonOverlapNeg" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString() + "Beta" + beta);
}
}
}
}
}
foreach (var container in Instance.Containers)
{
seenPieces.Clear();
foreach (var piece1 in Instance.PiecesWithVirtuals.OrderBy(p => p.ID))
{
seenPieces.Add(piece1);
foreach (var piece2 in Instance.PiecesWithVirtuals.OrderBy(p => p.ID).Except(seenPieces))
{
foreach (var cube1 in piece1.Original.Components.OrderBy(c => c.ID))
{
foreach (var cube2 in piece2.Original.Components.OrderBy(c => c.ID))
{
model.AddConstr(
LinearExpression.Sum(_betas.Select(beta =>
_sigmaPlus[beta, cube1, cube2, piece1, piece2] + _sigmaMinus[beta, cube1, cube2, piece1, piece2]))
>=
_itemIsPicked[piece1, container] + _itemIsPicked[piece2, container] - 1,
"NonOverlapLink" +
container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
if (Instance.Containers.Count() <= 1)
{
model.AddConstr(
LinearExpression.Sum(_betas.Select(beta =>
_sigmaPlus[beta, cube1, cube2, piece1, piece2] + _sigmaMinus[beta, cube1, cube2, piece1, piece2]))
<=
_itemIsPicked[piece1, container],
"NonOverlapRedundant1" +
container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
model.AddConstr(
LinearExpression.Sum(_betas.Select(beta =>
_sigmaPlus[beta, cube1, cube2, piece1, piece2] + _sigmaMinus[beta, cube1, cube2, piece1, piece2]))
<=
_itemIsPicked[piece2, container],
"NonOverlapRedundant2" +
container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
}
}
}
}
}
}
// Redundant volume limitation constraint
foreach (var container in Instance.Containers)
{
model.AddConstr(
LinearExpression.Sum(Instance.PiecesWithVirtuals.Select(piece =>
_itemIsPicked[piece, container] * piece.Volume))
<= (container.Mesh.Length * container.Mesh.Width * container.Mesh.Height),
"RedundantVolumeLimitation" + container.ToIdentString());
}
// Ensure that pieces do not protrude slants
foreach (var container in Instance.Containers)
{
foreach (var slant in container.Slants)
{
foreach (var piece in Instance.Pieces)
{
foreach (var component in piece.Original.Components)
{
// Use vertex depending on the normal vector of the slant
model.AddConstr(
((slant.NormalVector.X >= 0 ? _vertexPosition[1, 8, component, piece] : _vertexPosition[1, 1, component, piece]) - slant.Position.X) * slant.NormalVector.X +
((slant.NormalVector.Y >= 0 ? _vertexPosition[2, 8, component, piece] : _vertexPosition[2, 1, component, piece]) - slant.Position.Y) * slant.NormalVector.Y +
((slant.NormalVector.Z >= 0 ? _vertexPosition[3, 8, component, piece] : _vertexPosition[3, 1, component, piece]) - slant.Position.Z) * slant.NormalVector.Z <=
0 + (1 - _itemIsPicked[piece, container]) * slantBigM,
"StayInSlants" + slant.ToIdentString() + piece.ToIdentString() + component.ToIdentString() + container.ToIdentString()
);
}
}
}
}
// Fix virtual pieces to the predefined positions and orientations
foreach (var container in Instance.Containers)
{
foreach (var virtualPiece in container.VirtualPieces)
{
model.AddConstr(
_itemIsPicked[virtualPiece, container] == 1,
"VirtualPieceFixContainer" + container.ToIdentString() + virtualPiece.ToIdentString());
foreach (var orientation in MeshConstants.ORIENTATIONS)
{
model.AddConstr(
_itemOrientation[orientation, virtualPiece] == ((orientation == virtualPiece.FixedOrientation) ? 1 : 0),
"VirtualPieceFixOrientation" + container.ToIdentString() + virtualPiece.ToIdentString() + "O" + orientation.ToString());
}
foreach (var beta in _betas)
{
model.AddConstr(
_localReferenceFrameOrigin[beta, virtualPiece] == virtualPiece.FixedPosition[beta],
"VirtualPieceLocalReferenceFix" + container.ToIdentString() + virtualPiece.ToIdentString() + beta.ToString());
foreach (var component in virtualPiece.Original.Components)
{
foreach (var vertexID in MeshConstants.VERTEX_IDS)
{
model.AddConstr(
_vertexPosition[beta, vertexID, component, virtualPiece] ==
virtualPiece.FixedPosition[beta] + virtualPiece[virtualPiece.FixedOrientation][component.ID][vertexID][beta],
"VirtualPieceVertexFix" + container.ToIdentString() + virtualPiece.ToIdentString() + component.ToIdentString() + "VID" + vertexID.ToString() + "Beta" + beta.ToString());
}
}
}
}
}
// Ensure gravity-handling only if desired
if (Config.HandleGravity)
{
// Gravity constraints
foreach (var piece in Instance.Pieces.OrderBy(p => p.ID))
{
model.AddConstr(
_localReferenceFrameOrigin[3, piece] <= (1 - _locatedOnGround[piece]) * bigMSideLengthOverall,
"GravityGround" + piece.ToIdentString());
}
foreach (var piece1 in Instance.Pieces.OrderBy(p => p.ID))
{
foreach (var piece2 in Instance.PiecesWithVirtuals.Where(p => p != piece1))
{
// Track whether items are put into the same container
foreach (var container in Instance.Containers)
{
model.AddConstr(
_itemIsPicked[piece1, container] + _itemIsPicked[piece2, container] >=
2 * _bothInContainer[container, piece1, piece2],
"BothInSameContainer" + container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString());
}
foreach (var cube1 in piece1.Original.Components.OrderBy(c => c.ID))
{
foreach (var cube2 in piece2.Original.Components.OrderBy(c => c.ID))
{
// Ensure that the lower side of piece one has the height of the upper side of piece two if the corresponding gravity variable is activated
model.AddConstr(
_vertexPosition[3, 1, cube1, piece1] <=
_vertexPosition[3, 8, cube2, piece2] +
(1 - _locatedOn[cube1, cube2, piece1, piece2]) * bigMSideLengthOverall,
"GravityZ1" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
model.AddConstr(
_vertexPosition[3, 1, cube1, piece1] +
(1 - _locatedOn[cube1, cube2, piece1, piece2]) * bigMSideLengthOverall >=
_vertexPosition[3, 8, cube2, piece2],
"GravityZ2" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
// Ensure that the piece is located above the other piece respecting X when activated
model.AddConstr(
_vertexPosition[1, 0, cube1, piece1] >=
_vertexPosition[1, 1, cube2, piece2] -
(1 - _locatedOn[cube1, cube2, piece1, piece2]) * bigMSideLengthOverall,
"GravityX1" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
model.AddConstr(
_vertexPosition[1, 0, cube1, piece1] <=
_vertexPosition[1, 8, cube2, piece2] +
(1 - _locatedOn[cube1, cube2, piece1, piece2]) * bigMSideLengthOverall,
"GravityX2" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
// Ensure that the piece is located above the other piece respecting Y when activated
model.AddConstr(
_vertexPosition[2, 0, cube1, piece1] >=
_vertexPosition[2, 1, cube2, piece2] -
(1 - _locatedOn[cube1, cube2, piece1, piece2]) * bigMSideLengthOverall,
"GravityY1" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
model.AddConstr(
_vertexPosition[2, 0, cube1, piece1] <=
_vertexPosition[2, 8, cube2, piece2] +
(1 - _locatedOn[cube1, cube2, piece1, piece2]) * bigMSideLengthOverall,
"GravityY2" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
}
}
// Ensure the same container when located on another piece
model.AddConstr(
LinearExpression.Sum(Instance.Containers.Select(container =>
_bothInContainer[container, piece1, piece2])) >=
LinearExpression.Sum(piece1.Original.Components.Select(cube1 =>
LinearExpression.Sum(piece2.Original.Components.Select(cube2 =>
_locatedOn[cube1, cube2, piece1, piece2])))),
"SameContainerWhenLocatedOn" + piece1.ToIdentString() + piece2.ToIdentString());
}
}
// Ensure that one gravity requirement is met
foreach (var piece1 in Instance.Pieces)
{
model.AddConstr(
LinearExpression.Sum(Instance.PiecesWithVirtuals.Where(p => p != piece1).Select(piece2 =>
LinearExpression.Sum(piece1.Original.Components.Select(cube1 =>
LinearExpression.Sum(piece2.Original.Components.Select(cube2 =>
_locatedOn[cube1, cube2, piece1, piece2])))))) +
_locatedOnGround[piece1]
== 1,
"GravityEnsurance" + piece1.ToIdentString());
}
}
// Ensure material compatibility only if desired
if (Config.HandleCompatibility)
{
HashSet <VariablePiece> seenVariablePieces = new HashSet <VariablePiece>();
foreach (var piece1 in Instance.Pieces.OrderBy(p => p.ID))
{
seenVariablePieces.Add(piece1);
foreach (var piece2 in Instance.Pieces.OrderBy(p => p.ID).Except(seenVariablePieces).Where(p => p.Material.IncompatibleMaterials.Contains(piece1.Material.MaterialClass)))
{
foreach (var container in Instance.Containers)
{
model.AddConstr(
_itemIsPicked[piece1, container] + _itemIsPicked[piece2, container]
<= 1,
"MaterialCompatibility" + container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString());
}
}
}
}
// Ensure that items which are not marked as stackable won't get stacked on
if (Config.HandleStackability)
{
foreach (var piece1 in Instance.Pieces.Where(p => !p.Stackable))
{
foreach (var piece2 in Instance.Pieces.Where(p => p != piece1))
{
foreach (var cube1 in piece1.Original.Components)
{
foreach (var cube2 in piece2.Original.Components)
{
model.AddConstr(
_locatedOn[cube2, cube1, piece2, piece1]
== 0,
"Stackability" + piece1.ToIdentString() + piece2.ToIdentString() + cube1.ToIdentString() + cube2.ToIdentString());
}
}
}
}
}
// Ensure that no forbidden orientations get used
if (Config.HandleForbiddenOrientations)
{
foreach (var piece in Instance.Pieces)
{
foreach (var forbiddenOrientation in piece.ForbiddenOrientations)
{
model.AddConstr(
_itemOrientation[forbiddenOrientation, piece]
== 0,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
}
}
}
// Forbid any kind of rotation if rotatability is not desired
if (!Config.HandleRotatability)
{
foreach (var piece in Instance.Pieces)
{
foreach (var orientation in MeshConstants.ORIENTATIONS.Skip(1))
{
model.AddConstr(
_itemOrientation[orientation, piece]
== 0,
"NoRotatability" + piece.ToIdentString() + "O" + orientation.ToString());
}
}
}
// Keep model up-to-date
model.Update();
// Output some model statistics
Config.Log("Model statistics:" + Environment.NewLine);
Config.Log("ItemIsPicked: " + _itemIsPicked.Count + Environment.NewLine);
Config.Log("ContainerUsed: " + _containerUsed.Count + Environment.NewLine);
Config.Log("ItemOrientation: " + _itemOrientation.Count + Environment.NewLine);
Config.Log("LocalReferenceFrameOrigin: " + _localReferenceFrameOrigin.Count + Environment.NewLine);
Config.Log("VertexPosition: " + _vertexPosition.Count + Environment.NewLine);
Config.Log("Lambda: " + _lambda.Count + Environment.NewLine);
Config.Log("SigmaPlus: " + _sigmaPlus.Count + Environment.NewLine);
Config.Log("SigmaMinus: " + _sigmaMinus.Count + Environment.NewLine);
Config.Log("LocatedOnGround: " + _locatedOnGround.Count + Environment.NewLine);
Config.Log("LocatedOn: " + _locatedOn.Count + Environment.NewLine);
Config.Log("BothInContainer: " + _bothInContainer.Count + Environment.NewLine);
// Return
return(model);
}
/// <summary>
/// Transforms the object-model into a mathematical formulation
/// </summary>
/// <returns>The model</returns>
internal override LinearModel Transform()
{
// Init
LinearModel model = new LinearModel(ChosenSolver, Config.Log);
// TODO retrieve this stuff in a better way!?
double excessLengthShare = 0.1;
// Set big Ms
double bigMContainerLength = Instance.Containers.Max(c => c.Mesh.Length);
double bigMContainerWidth = Instance.Containers.Max(c => c.Mesh.Width);
double bigMContainerHeight = Instance.Containers.Max(c => c.Mesh.Height);
double bigM = Instance.Containers.Max(c => Math.Max(Math.Max(c.Mesh.Length, c.Mesh.Width), c.Mesh.Height));
double slantBigM =
Instance.Containers.Max(c => Math.Sqrt(Math.Pow(c.Mesh.Length, 2) + Math.Pow(c.Mesh.Width, 2) + Math.Pow(c.Mesh.Height, 2))) /
Instance.Containers.Min(c => Math.Sqrt(Math.Pow(c.Mesh.Length, 2) + Math.Pow(c.Mesh.Width, 2) + Math.Pow(c.Mesh.Height, 2)));
// --> Variables
_pieceIsInContainer = new VariableCollection <Piece, Container>(model, VariableType.Integer, 0, 1, (Piece piece, Container container) => { return("PieceInContainer" + piece.ToIdentString() + container.ToIdentString()); });
_containerUsed = new VariableCollection <Container>(model, VariableType.Integer, 0, 1, (Container container) => { return("ContainerIsUsed" + container.ToIdentString()); });
_frontLeftBottomX = new VariableCollection <Piece>(model, VariableType.Continuous, 0, bigMContainerLength, (Piece piece) => { return("FrontLeftBottomPositionX" + piece.ToIdentString()); });
_frontLeftBottomY = new VariableCollection <Piece>(model, VariableType.Continuous, 0, bigMContainerWidth, (Piece piece) => { return("FrontLeftBottomPositionY" + piece.ToIdentString()); });
_frontLeftBottomZ = new VariableCollection <Piece>(model, VariableType.Continuous, 0, bigMContainerHeight, (Piece piece) => { return("FrontLeftBottomPositionZ" + piece.ToIdentString()); });
_rearRightTopX = new VariableCollection <Piece>(model, VariableType.Continuous, 0, bigMContainerLength, (Piece piece) => { return("RearRightTopPositionX" + piece.ToIdentString()); });
_rearRightTopY = new VariableCollection <Piece>(model, VariableType.Continuous, 0, bigMContainerWidth, (Piece piece) => { return("RearRightTopPositionY" + piece.ToIdentString()); });
_rearRightTopZ = new VariableCollection <Piece>(model, VariableType.Continuous, 0, bigMContainerHeight, (Piece piece) => { return("RearRightTopPositionZ" + piece.ToIdentString()); });
_left = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("LeftFrom" + piece1.ToIdentString() + piece2.ToIdentString()); });
_right = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("RightFrom" + piece1.ToIdentString() + piece2.ToIdentString()); });
_behind = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("BehindFrom" + piece1.ToIdentString() + piece2.ToIdentString()); });
_front = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("FrontFrom" + piece1.ToIdentString() + piece2.ToIdentString()); });
_above = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("AboveFrom" + piece1.ToIdentString() + piece2.ToIdentString()); });
_below = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("BelowFrom" + piece1.ToIdentString() + piece2.ToIdentString()); });
_rotation = new VariableCollection <Piece, int, int>(model, VariableType.Integer, 0, 1, (Piece piece, int p, int q) => { return("Rotation" + piece.ToIdentString() + "p" + p + "q" + q); });
_bothInContainer = new VariableCollection <Container, Piece, Piece>(model, VariableType.Integer, 0, 1, (Container container, Piece piece1, Piece piece2) => { return("SameContainer" + container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString()); });
_locatedOn = new VariableCollection <Piece, Piece>(model, VariableType.Integer, 0, 1, (Piece piece1, Piece piece2) => { return("LocatedOn" + piece1.ToIdentString() + piece2.ToIdentString()); });
_locatedOnGround = new VariableCollection <Piece>(model, VariableType.Integer, 0, 1, (Piece piece) => { return("LocatedOnGround" + piece.ToIdentString()); });
// Keep model up-to-date
model.Update();
// --> Objective
switch (Config.Goal)
{
case OptimizationGoal.MinContainer:
{
// Minimize container count
model.SetObjective(
LinearExpression.Sum(Instance.Containers.Select(container => _containerUsed[container])),
OptimizationSense.Minimize);
}
break;
case OptimizationGoal.MaxUtilization:
{
// Maximize utilization
model.SetObjective(
LinearExpression.Sum(Instance.Pieces.Select(p => (p.Volume)
* LinearExpression.Sum(Instance.Containers.Select(c => _pieceIsInContainer[p, c])))),
OptimizationSense.Maximize);
}
break;
default:
break;
}
// --> Constraints
// Only assign to container if the container is in use
foreach (var container in Instance.Containers)
{
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
_pieceIsInContainer[piece, container] <= _containerUsed[container],
"OnlyAssignIfContainerIsUsed" + container.ToIdentString() + piece.ToIdentString());
}
}
// Ensure that piece is only added to one container
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
(Config.Goal == OptimizationGoal.MaxUtilization) ?
LinearExpression.Sum(Instance.Containers.Select(c => _pieceIsInContainer[piece, c])) <= 1 :
LinearExpression.Sum(Instance.Containers.Select(c => _pieceIsInContainer[piece, c])) == 1,
"AssignToSingleContainer" + piece.ToIdentString());
}
// Ensure that the gross weight is not exceeded // TODO enable again!?
//foreach (var container in _instance.Containers)
//{
// model.AddConstraint(
// Expression.Sum(_instance.Pieces.Select(p => _pieceIsInContainer[p, container] * p.Weight)) <= containerGrossWeight,
// "GrossWeightCapacityLimitation" + container.ToIdentString());
//}
// Ensure that the pieces stay in the container
foreach (var piece in Instance.Pieces)
{
foreach (var container in Instance.Containers)
{
// Consider X-value
model.AddConstr(
_rearRightTopX[piece] <= bigMContainerLength - ((bigMContainerLength - container.Mesh.Length) * _pieceIsInContainer[piece, container]),
"StayInsideX" + piece.ToIdentString() + container.ToIdentString());
// Consider Y-value
model.AddConstr(
_rearRightTopY[piece] <= bigMContainerWidth - ((bigMContainerWidth - container.Mesh.Width) * _pieceIsInContainer[piece, container]),
"StayInsideY" + piece.ToIdentString() + container.ToIdentString());
// Consider Z-value
model.AddConstr(
_rearRightTopZ[piece] <= bigMContainerHeight - ((bigMContainerHeight - container.Mesh.Height) * _pieceIsInContainer[piece, container]),
"StayInsideZ" + piece.ToIdentString() + container.ToIdentString());
}
}
// Ensure that pieces do not protrude slants
foreach (var container in Instance.Containers)
{
foreach (var slant in container.Slants)
{
foreach (var piece in Instance.Pieces)
{
// Use vertex depending on the normal vector of the slant
model.AddConstr(
((slant.NormalVector.X >= 0 ? _rearRightTopX[piece] : _frontLeftBottomX[piece]) - slant.Position.X) * slant.NormalVector.X +
((slant.NormalVector.Y >= 0 ? _rearRightTopY[piece] : _frontLeftBottomY[piece]) - slant.Position.Y) * slant.NormalVector.Y +
((slant.NormalVector.Z >= 0 ? _rearRightTopZ[piece] : _frontLeftBottomZ[piece]) - slant.Position.Z) * slant.NormalVector.Z <=
0 + (1 - _pieceIsInContainer[piece, container]) * slantBigM,
"StayInSlants" + slant.ToIdentString() + piece.ToIdentString() + container.ToIdentString()
);
}
}
}
// Ensure that the boxes can rotate by 90 degrees
foreach (var piece in Instance.Pieces)
{
// Set x-value
model.AddConstr(
_rearRightTopX[piece] - _frontLeftBottomX[piece] ==
_rotation[piece, 1, 1] * piece.Original.BoundingBox.Length +
_rotation[piece, 1, 2] * piece.Original.BoundingBox.Width +
_rotation[piece, 1, 3] * piece.Original.BoundingBox.Height,
"RotationXValue" + piece.ToIdentString());
// Set y-value
model.AddConstr(
_rearRightTopY[piece] - _frontLeftBottomY[piece] ==
_rotation[piece, 2, 1] * piece.Original.BoundingBox.Length +
_rotation[piece, 2, 2] * piece.Original.BoundingBox.Width +
_rotation[piece, 2, 3] * piece.Original.BoundingBox.Height,
"RotationYValue" + piece.ToIdentString());
// Set z-value
model.AddConstr(
_rearRightTopZ[piece] - _frontLeftBottomZ[piece] ==
_rotation[piece, 3, 1] * piece.Original.BoundingBox.Length +
_rotation[piece, 3, 2] * piece.Original.BoundingBox.Width +
_rotation[piece, 3, 3] * piece.Original.BoundingBox.Height,
"RotationZValue" + piece.ToIdentString());
}
foreach (var piece in Instance.Pieces)
{
foreach (var q in _rotationIndexes)
{
model.AddConstr(
LinearExpression.Sum(_rotationIndexes.Select(p => _rotation[piece, p, q])) == 1,
"RotationHelper1" + piece.ToIdentString() + "q" + q);
}
foreach (var p in _rotationIndexes)
{
model.AddConstr(
LinearExpression.Sum(_rotationIndexes.Select(q => _rotation[piece, p, q])) == 1,
"RotationHelper2" + piece.ToIdentString() + "p" + p);
}
}
// Link FLB corner point with RRT corner point for virtual pieces
foreach (var container in Instance.Containers)
{
foreach (var virtualPiece in container.VirtualPieces)
{
model.AddConstr(
_rearRightTopX[virtualPiece] - _frontLeftBottomX[virtualPiece] == virtualPiece[virtualPiece.FixedOrientation].BoundingBox.Length,
"LinkFLBRRTX" + container.ToIdentString() + virtualPiece.ToIdentString());
model.AddConstr(
_rearRightTopY[virtualPiece] - _frontLeftBottomY[virtualPiece] == virtualPiece[virtualPiece.FixedOrientation].BoundingBox.Width,
"LinkFLBRRTY" + container.ToIdentString() + virtualPiece.ToIdentString());
model.AddConstr(
_rearRightTopZ[virtualPiece] - _frontLeftBottomZ[virtualPiece] == virtualPiece[virtualPiece.FixedOrientation].BoundingBox.Height,
"LinkFLBRRTZ" + container.ToIdentString() + virtualPiece.ToIdentString());
}
}
// Link the variables
foreach (var container in Instance.Containers)
{
// Remember seen pieces
HashSet <Piece> seenPieces = new HashSet <Piece>();
// Iterate pieces
foreach (var piece in Instance.PiecesWithVirtuals)
{
// Remember piece
seenPieces.Add(piece);
// Iterate pieces (inner)
foreach (var secondPiece in Instance.PiecesWithVirtuals.Except(seenPieces))
{
model.AddConstr(
_frontLeftBottomX[piece]
- _rearRightTopX[secondPiece]
+ ((1 - _left[secondPiece, piece]) * bigM)
+ ((2 - (_pieceIsInContainer[piece, container] + _pieceIsInContainer[secondPiece, container])) * bigM)
>= 0,
"Link1" + container.ToIdentString() + piece.ToIdentString() + secondPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomX[secondPiece]
- _rearRightTopX[piece]
+ ((1 - _right[secondPiece, piece]) * bigM)
+ ((2 - (_pieceIsInContainer[piece, container] + _pieceIsInContainer[secondPiece, container])) * bigM)
>= 0,
"Link2" + container.ToIdentString() + piece.ToIdentString() + secondPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomY[piece]
- _rearRightTopY[secondPiece]
+ ((1 - _behind[secondPiece, piece]) * bigM)
+ ((2 - (_pieceIsInContainer[piece, container] + _pieceIsInContainer[secondPiece, container])) * bigM)
>= 0,
"Link3" + container.ToIdentString() + piece.ToIdentString() + secondPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomY[secondPiece]
- _rearRightTopY[piece]
+ ((1 - _front[secondPiece, piece]) * bigM)
+ ((2 - (_pieceIsInContainer[piece, container] + _pieceIsInContainer[secondPiece, container])) * bigM)
>= 0,
"Link4" + container.ToIdentString() + piece.ToIdentString() + secondPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomZ[piece]
- _rearRightTopZ[secondPiece]
+ ((1 - _above[secondPiece, piece]) * bigM)
+ ((2 - (_pieceIsInContainer[piece, container] + _pieceIsInContainer[secondPiece, container])) * bigM)
>= 0,
"Link5" + container.ToIdentString() + piece.ToIdentString() + secondPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomZ[secondPiece]
- _rearRightTopZ[piece]
+ ((1 - _below[secondPiece, piece]) * bigM)
+ ((2 - (_pieceIsInContainer[piece, container] + _pieceIsInContainer[secondPiece, container])) * bigM)
>= 0,
"Link6" + container.ToIdentString() + piece.ToIdentString() + secondPiece.ToIdentString());
}
}
}
// Ensure non-overlapping
foreach (var piece in Instance.PiecesWithVirtuals)
{
foreach (var secondPiece in Instance.PiecesWithVirtuals)
{
model.AddConstr(
_left[secondPiece, piece] +
_right[secondPiece, piece] +
_behind[secondPiece, piece] +
_front[secondPiece, piece] +
_above[secondPiece, piece] +
_below[secondPiece, piece] >= 1,
"EnsureNonOverlapping" + piece.ToIdentString() + secondPiece.ToIdentString());
}
}
// Redundant volume limitation constraints
foreach (var container in Instance.Containers)
{
model.AddConstr(
LinearExpression.Sum(Instance.PiecesWithVirtuals.Select(piece =>
_pieceIsInContainer[piece, container] * piece.Original.BoundingBox.Volume))
<= (container.Mesh.Length * container.Mesh.Width * container.Mesh.Height),
"RedundantVolumeLimitation" + container.ToIdentString());
}
// Fix virtual pieces to the predefined positions and orientations
foreach (var container in Instance.Containers)
{
foreach (var virtualPiece in container.VirtualPieces)
{
model.AddConstr(
_pieceIsInContainer[virtualPiece, container] == 1,
"VirtualPieceFixContainer" + container.ToIdentString() + virtualPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomX[virtualPiece] == virtualPiece.FixedPosition.X,
"VirtualPieceFixPositionX" + container.ToIdentString() + virtualPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomY[virtualPiece] == virtualPiece.FixedPosition.Y,
"VirtualPieceFixPositionY" + container.ToIdentString() + virtualPiece.ToIdentString());
model.AddConstr(
_frontLeftBottomZ[virtualPiece] == virtualPiece.FixedPosition.Z,
"VirtualPieceFixPositionZ" + container.ToIdentString() + virtualPiece.ToIdentString());
}
}
// Ensure gravity only if desired
if (Config.HandleGravity)
{
// Gravity
Piece[] supporteeArray = Instance.Pieces.ToArray();
Piece[] supporterArray = Instance.PiecesWithVirtuals.ToArray();
_pieceTuples = new List <Tuple <Piece, Piece> >();
for (int i = 0; i < supporteeArray.Length; i++)
{
for (int j = 0; j < supporterArray.Length; j++)
{
if (supporteeArray[i] != supporterArray[j])
{
_pieceTuples.Add(new Tuple <Piece, Piece>(supporteeArray[i], supporterArray[j]));
}
}
}
foreach (var tuple in _pieceTuples)
{
// Z-distance has to equal 0 if located on the specified piece
model.AddConstr(
_frontLeftBottomZ[tuple.Item1] <=
_rearRightTopZ[tuple.Item2] +
(1 - _locatedOn[tuple.Item1, tuple.Item2]) * bigM,
"EnsureGravityZ1-" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
model.AddConstr(
_frontLeftBottomZ[tuple.Item1] +
(1 - _locatedOn[tuple.Item1, tuple.Item2]) * bigM >=
_rearRightTopZ[tuple.Item2],
"EnsureGravityZ2-" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
// Located on another piece regarding X and Y - respectively stability
model.AddConstr(
_rearRightTopY[tuple.Item1]
<= _rearRightTopY[tuple.Item2]
+ (excessLengthShare * (_rearRightTopY[tuple.Item1] - _frontLeftBottomY[tuple.Item1]))
+ (bigM * (1 - _locatedOn[tuple.Item1, tuple.Item2])),
"EnsureStabilityY1-" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
model.AddConstr(
_rearRightTopX[tuple.Item1]
<= _rearRightTopX[tuple.Item2]
+ (excessLengthShare * (_rearRightTopX[tuple.Item1] - _frontLeftBottomX[tuple.Item1]))
+ (bigM * (1 - _locatedOn[tuple.Item1, tuple.Item2])),
"EnsureStabilityX1-" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
model.AddConstr(
_frontLeftBottomY[tuple.Item1]
>= _frontLeftBottomY[tuple.Item2]
- (excessLengthShare * (_rearRightTopY[tuple.Item1] - _frontLeftBottomY[tuple.Item1]))
- (bigM * (1 - _locatedOn[tuple.Item1, tuple.Item2])),
"EnsureStabilityY2-" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
model.AddConstr(
_frontLeftBottomX[tuple.Item1]
>= _frontLeftBottomX[tuple.Item2]
- (excessLengthShare * (_rearRightTopX[tuple.Item1] - _frontLeftBottomX[tuple.Item1]))
- (bigM * (1 - _locatedOn[tuple.Item1, tuple.Item2])),
"EnsureStabilityX2-" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
// Track whether items are put into the same container
foreach (var container in Instance.Containers)
{
model.AddConstr(
_pieceIsInContainer[tuple.Item1, container] + _pieceIsInContainer[tuple.Item2, container] >=
2 * _bothInContainer[container, tuple.Item1, tuple.Item2],
"BothInSameContainer" + container.ToIdentString() + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
}
// Ensure the same container when located on another piece
model.AddConstr(
LinearExpression.Sum(Instance.Containers.Select(container =>
_bothInContainer[container, tuple.Item1, tuple.Item2])) >=
_locatedOn[tuple.Item1, tuple.Item2],
"SameContainerWhenLocatedOn" + tuple.Item1.ToIdentString() + tuple.Item2.ToIdentString());
}
// Located on ground if no piece is below the specified one
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
_frontLeftBottomZ[piece] <= (1 - _locatedOnGround[piece]) * bigM,
"LocatedOnGround" + piece.ToIdentString());
}
// Locate pieces on other pieces or the ground
foreach (var piece in Instance.Pieces)
{
model.AddConstr(
LinearExpression.Sum(_pieceTuples
.Where(t => t.Item1 == piece)
.Select(tuple => _locatedOn[tuple.Item1, tuple.Item2])) +
_locatedOnGround[piece]
== 1,
"LocatedOnAnotherPiece-" + piece.ToIdentString());
}
}
// Ensure material compatibility only if desired
if (Config.HandleCompatibility)
{
HashSet <VariablePiece> seenPieces = new HashSet <VariablePiece>();
foreach (var piece1 in Instance.Pieces.OrderBy(p => p.ID))
{
seenPieces.Add(piece1);
foreach (var piece2 in Instance.Pieces.OrderBy(p => p.ID).Except(seenPieces).Where(p => p.Material.IncompatibleMaterials.Contains(piece1.Material.MaterialClass)))
{
foreach (var container in Instance.Containers)
{
model.AddConstr(
_pieceIsInContainer[piece1, container] + _pieceIsInContainer[piece2, container]
<= 1,
"MaterialCompatibility" + container.ToIdentString() + piece1.ToIdentString() + piece2.ToIdentString());
}
}
}
}
// Ensure that items which are not marked as stackable won't get stacked on
if (Config.HandleStackability)
{
foreach (var piece1 in Instance.Pieces.Where(p => !p.Stackable))
{
foreach (var piece2 in Instance.Pieces.Where(p => p != piece1))
{
model.AddConstr(
_locatedOn[piece2, piece1]
== 0,
"Stackability" + piece1.ToIdentString() + piece2.ToIdentString());
}
}
}
// Ensure that no forbidden orientations get used
if (Config.HandleForbiddenOrientations)
{
foreach (var piece in Instance.Pieces)
{
foreach (var forbiddenOrientation in piece.ForbiddenOrientations)
{
switch (forbiddenOrientation)
{
case 0:
model.AddConstr(
_rotation[piece, 1, 1] + _rotation[piece, 2, 2] + _rotation[piece, 3, 3] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
break;
case 2:
model.AddConstr(
_rotation[piece, 1, 1] + _rotation[piece, 2, 3] + _rotation[piece, 3, 2] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
break;
case 8:
model.AddConstr(
_rotation[piece, 1, 2] + _rotation[piece, 2, 1] + _rotation[piece, 3, 3] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
break;
case 10:
model.AddConstr(
_rotation[piece, 1, 3] + _rotation[piece, 2, 1] + _rotation[piece, 3, 2] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
break;
case 16:
model.AddConstr(
_rotation[piece, 1, 2] + _rotation[piece, 2, 3] + _rotation[piece, 3, 1] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
break;
case 18:
model.AddConstr(
_rotation[piece, 1, 3] + _rotation[piece, 2, 2] + _rotation[piece, 3, 1] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + forbiddenOrientation.ToString());
break;
default:
break;
}
}
}
}
// Forbid any kind of rotation if rotatability is not desired
if (!Config.HandleRotatability)
{
foreach (var piece in Instance.Pieces)
{
foreach (var orientation in MeshConstants.ORIENTATIONS.Skip(1))
{
switch (orientation)
{
case 0:
model.AddConstr(
_rotation[piece, 1, 1] + _rotation[piece, 2, 2] + _rotation[piece, 3, 3] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + orientation.ToString());
break;
case 2:
model.AddConstr(
_rotation[piece, 1, 1] + _rotation[piece, 2, 3] + _rotation[piece, 3, 2] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + orientation.ToString());
break;
case 8:
model.AddConstr(
_rotation[piece, 1, 2] + _rotation[piece, 2, 1] + _rotation[piece, 3, 3] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + orientation.ToString());
break;
case 10:
model.AddConstr(
_rotation[piece, 1, 3] + _rotation[piece, 2, 1] + _rotation[piece, 3, 2] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + orientation.ToString());
break;
case 16:
model.AddConstr(
_rotation[piece, 1, 2] + _rotation[piece, 2, 3] + _rotation[piece, 3, 1] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + orientation.ToString());
break;
case 18:
model.AddConstr(
_rotation[piece, 1, 3] + _rotation[piece, 2, 2] + _rotation[piece, 3, 1] <= 2,
"ForbiddenOrientation" + piece.ToIdentString() + "O" + orientation.ToString());
break;
default:
break;
}
}
}
}
// Keep model up-to-date
model.Update();
// Output some model statistics
Config.Log("Model statistics:" + Environment.NewLine);
Config.Log("PieceIsInContainer: " + _pieceIsInContainer.Count + Environment.NewLine);
Config.Log("ContainerUsed: " + _containerUsed.Count + Environment.NewLine);
Config.Log("FrontLeftBottomX: " + _frontLeftBottomX.Count + Environment.NewLine);
Config.Log("FrontLeftBottomY: " + _frontLeftBottomY.Count + Environment.NewLine);
Config.Log("FrontLeftBottomZ: " + _frontLeftBottomZ.Count + Environment.NewLine);
Config.Log("RearRightTopX: " + _rearRightTopX.Count + Environment.NewLine);
Config.Log("RearRightTopY: " + _rearRightTopY.Count + Environment.NewLine);
Config.Log("RearRightTopZ: " + _rearRightTopZ.Count + Environment.NewLine);
Config.Log("Left: " + _left.Count + Environment.NewLine);
Config.Log("Right: " + _right.Count + Environment.NewLine);
Config.Log("Behind: " + _behind.Count + Environment.NewLine);
Config.Log("Front: " + _front.Count + Environment.NewLine);
Config.Log("Above: " + _above.Count + Environment.NewLine);
Config.Log("Below: " + _below.Count + Environment.NewLine);
Config.Log("Rotation: " + _rotation.Count + Environment.NewLine);
Config.Log("BothInContainer: " + _bothInContainer.Count + Environment.NewLine);
Config.Log("LocatedOn: " + _locatedOn.Count + Environment.NewLine);
Config.Log("LocatedOnGround: " + _locatedOnGround.Count + Environment.NewLine);
// Return
return(model);
}
private void AnalyzeServiceUnits()
{
// Keep track of count
int overallCount = _serviceUnits.Count * _config.GroupsIndividuals.Count;
int counter = 0;
// --> Solve all
_config.LogLine("Analyzing all service units within all given groups - " + overallCount + " to go!");
// Iterate all groups (use a dummy group if no grouping has to be done - this should work ok with the interior part of the loops)
foreach (var groupIdents in _config.GroupsIndividuals)
{
// Investigate all service units for this group within the given scenario
foreach (var serviceUnitInFocus in _serviceUnits)
{
// Log
_config.Log((++counter) + "/" + overallCount + ": " + serviceUnitInFocus.Ident + "/" + (groupIdents.Any() ? string.Join(",", groupIdents.Select(i => i.Item2)) : "Overall") + " (SU/group)");
// Init
LinearModel model = new LinearModel(_config.SolverChoice, null /* Disable output flood for now, use following to enable: (string s) => { _config.Log(s); } */);
// --> Init variables
Variable efficiencyRating = new Variable(model, VariableType.Continuous, double.NegativeInfinity, double.PositiveInfinity, "EfficiencyRating");
VariableCollection <ServiceUnit> weights = new VariableCollection <ServiceUnit>(model, VariableType.Continuous, 0, double.PositiveInfinity, (ServiceUnit u) => { return(u.Ident); });
// --> Build model
// Add objective
if (_config.InputOriented)
{
model.SetObjective(efficiencyRating + 0, OptimizationSense.Minimize);
}
else
{
model.SetObjective(efficiencyRating + 0, OptimizationSense.Maximize);
}
// Add input constraints
if (_config.Inputs.Any())
{
foreach (var inputEntry in _config.Inputs)
{
// Shift and flip (if required) all values
Dictionary <ServiceUnit, double> inputValues = _serviceUnits.ToDictionary(
k => k,
s => s.GetValue(inputEntry.Item1, (FootprintDatapoint f) => { return(groupIdents.All(g => g.Item2 == f[g.Item1].ToString())); }));
// In case of loss values, convert them
if (inputEntry.Item2 == InputType.Hindrance)
{
switch (inputEntry.Item1)
{
case FootprintDatapoint.FootPrintEntry.SKUs:
// Simply inverse them
foreach (var serviceUnit in inputValues.Keys.ToList())
{
inputValues[serviceUnit] = 1.0 / inputValues[serviceUnit];
}
break;
default:
// Simply flip them (next step will convert the numbers to positive ones again)
foreach (var serviceUnit in inputValues.Keys.ToList())
{
inputValues[serviceUnit] *= -1;
}
break;
}
}
// If there is a negative value, shift all values to positive ones
double minOutputValue = inputValues.Min(v => v.Value);
if (minOutputValue < 0)
{
foreach (var serviceUnit in inputValues.Keys.ToList())
{
inputValues[serviceUnit] += Math.Abs(minOutputValue);
}
}
// Add constraint
if (_config.InputOriented)
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => inputValues[s]), _serviceUnits.Select(s => weights[s])) <=
// Shall be smaller than the weighted input of the service unit in focus
efficiencyRating * inputValues[serviceUnitInFocus], "Input" + inputEntry);
}
else
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => inputValues[s]), _serviceUnits.Select(s => weights[s])) <=
// Shall be smaller than the weighted input of the service unit in focus
inputValues[serviceUnitInFocus], "Input" + inputEntry);
}
}
}
else
{
// Add constant uniform inputs for all service units
if (_config.InputOriented)
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => 1.0), _serviceUnits.Select(s => weights[s])) <=
// Shall be smaller than the weighted input of the service unit in focus
efficiencyRating * 1.0, "InputConstant");
}
else
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => 1.0), _serviceUnits.Select(s => weights[s])) <=
// Shall be smaller than the weighted input of the service unit in focus
1.0, "InputConstant");
}
}
// Add output constraints
if (_config.Outputs.Any())
{
// Add output constraint using the actual entry
foreach (var outputEntry in _config.Outputs)
{
// Shift and flip (if required) all values
Dictionary <ServiceUnit, double> outputValues = _serviceUnits.ToDictionary(
k => k,
s => s.GetValue(outputEntry.Item1, (FootprintDatapoint f) => { return(groupIdents.All(g => g.Item2 == f[g.Item1].ToString())); }));
// Store performance for this measure
foreach (var serviceUnit in _serviceUnits)
{
_serviceUnitOutputMeasures[serviceUnit, outputEntry.Item1] = outputValues[serviceUnit];
}
// In case of loss values, convert them
if (outputEntry.Item2 == OutputType.Loss)
{
switch (outputEntry.Item1)
{
case FootprintDatapoint.FootPrintEntry.OrderTurnoverTimeAvg:
case FootprintDatapoint.FootPrintEntry.OrderTurnoverTimeMed:
case FootprintDatapoint.FootPrintEntry.OrderTurnoverTimeLQ:
case FootprintDatapoint.FootPrintEntry.OrderTurnoverTimeUQ:
case FootprintDatapoint.FootPrintEntry.OrderThroughputTimeAvg:
case FootprintDatapoint.FootPrintEntry.OrderThroughputTimeMed:
case FootprintDatapoint.FootPrintEntry.OrderThroughputTimeLQ:
case FootprintDatapoint.FootPrintEntry.OrderThroughputTimeUQ:
case FootprintDatapoint.FootPrintEntry.BundleTurnoverTimeAvg:
case FootprintDatapoint.FootPrintEntry.BundleTurnoverTimeMed:
case FootprintDatapoint.FootPrintEntry.BundleTurnoverTimeLQ:
case FootprintDatapoint.FootPrintEntry.BundleTurnoverTimeUQ:
case FootprintDatapoint.FootPrintEntry.BundleThroughputTimeAvg:
case FootprintDatapoint.FootPrintEntry.BundleThroughputTimeMed:
case FootprintDatapoint.FootPrintEntry.BundleThroughputTimeLQ:
case FootprintDatapoint.FootPrintEntry.BundleThroughputTimeUQ:
// Simply inverse them
foreach (var serviceUnit in outputValues.Keys.ToList())
{
outputValues[serviceUnit] = 1.0 / outputValues[serviceUnit];
}
break;
case FootprintDatapoint.FootPrintEntry.OSIdleTimeAvg:
case FootprintDatapoint.FootPrintEntry.OSIdleTimeMed:
case FootprintDatapoint.FootPrintEntry.OSIdleTimeLQ:
case FootprintDatapoint.FootPrintEntry.OSIdleTimeUQ:
case FootprintDatapoint.FootPrintEntry.ISIdleTimeAvg:
case FootprintDatapoint.FootPrintEntry.ISIdleTimeMed:
case FootprintDatapoint.FootPrintEntry.ISIdleTimeLQ:
case FootprintDatapoint.FootPrintEntry.ISIdleTimeUQ:
case FootprintDatapoint.FootPrintEntry.OSDownTimeAvg:
case FootprintDatapoint.FootPrintEntry.OSDownTimeMed:
case FootprintDatapoint.FootPrintEntry.OSDownTimeLQ:
case FootprintDatapoint.FootPrintEntry.OSDownTimeUQ:
case FootprintDatapoint.FootPrintEntry.ISDownTimeAvg:
case FootprintDatapoint.FootPrintEntry.ISDownTimeMed:
case FootprintDatapoint.FootPrintEntry.ISDownTimeLQ:
case FootprintDatapoint.FootPrintEntry.ISDownTimeUQ:
case FootprintDatapoint.FootPrintEntry.LateOrdersFractional:
// As these should be values between 0.0 and 1.0 just flip them within the range
{
if (outputValues.Values.Any(v => v < 0 || v > 1))
{
throw new ArgumentException("Expected values to be within the range [0,1], but found one out of range!");
}
foreach (var serviceUnit in outputValues.Keys.ToList())
{
outputValues[serviceUnit] = 1.0 - outputValues[serviceUnit];
}
}
break;
case FootprintDatapoint.FootPrintEntry.TimingDecisionsOverall:
case FootprintDatapoint.FootPrintEntry.TimingPathPlanningAvg:
case FootprintDatapoint.FootPrintEntry.TimingPathPlanningOverall:
case FootprintDatapoint.FootPrintEntry.TimingPathPlanningCount:
case FootprintDatapoint.FootPrintEntry.TimingTaskAllocationAvg:
case FootprintDatapoint.FootPrintEntry.TimingTaskAllocationOverall:
case FootprintDatapoint.FootPrintEntry.TimingTaskAllocationCount:
case FootprintDatapoint.FootPrintEntry.TimingItemStorageAvg:
case FootprintDatapoint.FootPrintEntry.TimingItemStorageOverall:
case FootprintDatapoint.FootPrintEntry.TimingItemStorageCount:
case FootprintDatapoint.FootPrintEntry.TimingPodStorageAvg:
case FootprintDatapoint.FootPrintEntry.TimingPodStorageOverall:
case FootprintDatapoint.FootPrintEntry.TimingPodStorageCount:
case FootprintDatapoint.FootPrintEntry.TimingRepositioningAvg:
case FootprintDatapoint.FootPrintEntry.TimingRepositioningOverall:
case FootprintDatapoint.FootPrintEntry.TimingRepositioningCount:
case FootprintDatapoint.FootPrintEntry.TimingReplenishmentBatchingAvg:
case FootprintDatapoint.FootPrintEntry.TimingReplenishmentBatchingOverall:
case FootprintDatapoint.FootPrintEntry.TimingReplenishmentBatchingCount:
case FootprintDatapoint.FootPrintEntry.TimingOrderBatchingAvg:
case FootprintDatapoint.FootPrintEntry.TimingOrderBatchingOverall:
case FootprintDatapoint.FootPrintEntry.TimingOrderBatchingCount:
// Simply inverse them
foreach (var serviceUnit in outputValues.Keys.ToList())
{
outputValues[serviceUnit] = 1.0 / outputValues[serviceUnit];
}
break;
default:
// Simply flip them (next step will convert the numbers to positive ones again)
foreach (var serviceUnit in outputValues.Keys.ToList())
{
outputValues[serviceUnit] *= -1;
}
break;
}
}
// If there is a negative value, shift all values to positive ones
double minOutputValue = outputValues.Min(v => v.Value);
if (minOutputValue < 0)
{
foreach (var serviceUnit in outputValues.Keys.ToList())
{
outputValues[serviceUnit] += Math.Abs(minOutputValue);
}
}
// Add constraint
if (_config.InputOriented)
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => outputValues[s]), _serviceUnits.Select(s => weights[s])) >=
// Shall be smaller than the weighted input of the service unit in focus
outputValues[serviceUnitInFocus], "Output" + outputEntry);
}
else
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => outputValues[s]), _serviceUnits.Select(s => weights[s])) >=
// Shall be smaller than the weighted input of the service unit in focus
efficiencyRating * outputValues[serviceUnitInFocus], "Output" + outputEntry);
}
}
}
else
{
// Add constant uniform outputs for all service units
if (_config.InputOriented)
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => 1.0), _serviceUnits.Select(s => weights[s])) >=
// Shall be smaller than the weighted input of the service unit in focus
1.0, "OutputConstant");
}
else
{
model.AddConstr(
// Sum of all other weighted inputs
LinearExpression.Sum(_serviceUnits.Select(s => 1.0), _serviceUnits.Select(s => weights[s])) >=
// Shall be smaller than the weighted input of the service unit in focus
efficiencyRating * 1.0, "OutputConstant");
}
}
// Sum weights
if (_config.WeightsSumToOne)
{
// Summed weights have to be equal to one
model.AddConstr(LinearExpression.Sum(_serviceUnits.Select(s => weights[s])) == 1.0, "WeightSum");
}
// Commit changes
model.Update();
// --> Solve model
model.Optimize();
// --> Get solution
if (!model.HasSolution())
{
throw new InvalidOperationException("Model is infeasible for service unit: " + serviceUnitInFocus.Ident);
}
_serviceUnitScores[groupIdents, serviceUnitInFocus] = efficiencyRating.Value;
_config.LogLine(" - Efficiency: " + (efficiencyRating.Value * 100).ToString(IOConstants.FORMATTER) + " %");
}
// Transform efficiency
if (!_config.InputOriented && _config.TransformOutputOrientedEfficiency)
{
//double maxEfficiency = _serviceUnits.Max(s => _serviceUnitScores[groupIdents, s]);
foreach (var serviceUnit in _serviceUnits)
{
_serviceUnitScores[groupIdents, serviceUnit] = 1.0 / _serviceUnitScores[groupIdents, serviceUnit];
}
// _serviceUnitScores[groupIdents, serviceUnit] /= maxEfficiency;
}
}
}
//public RuleOrientedTransformation(Expression expr, IRuleScope rules = null) : this(rules)
//{
// this.result = Transform(expr);
//}
public Expression Transform(Expression expr, Func <Expression, Expression> subTransform)
{
if (expr is LinearExpression)
{
LinearExpression lexpr = (LinearExpression)expr;
IList <Rule> exprRules = rules.GetRules(r => r.Pattern is BinaryExpression && ((BinaryExpression)r.Pattern).Operator == lexpr.Operator);
IList <Expression> list = new List <Expression>();
foreach (Expression item in lexpr.List)
{
list.Add(subTransform(item));
}
//list.Add(new LinearToBinary(Transform(item)).Result);
IList <Expression> rlist = new List <Expression>();
for (int i = 0; i < list.Count; i++)
{
Expression left = list[i];
Expression right = null;
Expression result = null;
int j = i + 1;
for (; j < list.Count; j++)
{
right = list[j];
Expression optionA = Expression.FromBinary(lexpr.Operator, left, right);
Expression optionB = Expression.FromBinary(lexpr.Operator, right, left);
foreach (Rule rule in exprRules)
{
result = rule.Apply(optionA);
if (result == null)
{
result = rule.Apply(optionB);
}
if (result != null)
{
break;
}
}
if (result != null)
{
break;
}
}
if (result != null)
{
list.RemoveAt(j);
list.RemoveAt(i);
list.Insert(i, result);
i--;
}
}
return(new LinearExpression(lexpr.Operator, list));
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Expression left = subTransform(bexpr.Left);
Expression right = subTransform(bexpr.Right);
//Expression left = (new LinearToBinary(Transform(bexpr.Left))).Result;
//Expression right = (new LinearToBinary(Transform(bexpr.Right))).Result;
Expression full = Expression.FromBinary(bexpr.Operator, left, right);
IList <Rule> exprRules = rules.GetRules(r => r.Pattern is BinaryExpression && ((BinaryExpression)r.Pattern).Operator == bexpr.Operator);
foreach (Rule rule in exprRules)
{
Expression result = rule.Apply(full);
if (result != null)
{
return(result);
}
}
return(full);
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
IList <Expression> args = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
args.Add(subTransform(arg));
}
FunctionExpression full = (FunctionExpression)Expression.Function(fexpr.Name, args);
IList <Rule> exprRules = rules.GetRules(r => r.Pattern is FunctionExpression && ((FunctionExpression)r.Pattern).Name == fexpr.Name && ((FunctionExpression)r.Pattern).Arguments.Count == fexpr.Arguments.Count);
foreach (Rule rule in exprRules)
{
Expression result = rule.Apply(full);
if (result != null)
{
return(result);
}
}
return(full);
}
return(expr);
}
public Expression Simplify(Expression expr)
{
if (expr is VariableExpression)
{
VariableExpression vexpr = (VariableExpression)expr;
string name = vexpr.Name;
if (existsVariable(name))
{
return(getVariable(name));
}
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
string name = fexpr.Name;
bool exists = existsFunction(name);
if (exists && !acceptsFunction(name, fexpr.Arguments.Count))
{
throw new Exception("Function doesn't accept as many arguments");
}
IList <double> varguments = new List <double>();
IList <Expression> arguments = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
Expression sarg = Simplify(arg);
arguments.Add(sarg);
if (sarg is NumberExpression)
{
varguments.Add(((NumberExpression)sarg).Value);
}
}
if (exists)
{
if (varguments.Count == arguments.Count)
{
return(Expression.Number(calculateFunction(name, varguments)));
}
return(evaluateFunction(name, arguments));
}
else
{
return(Expression.Function(name, arguments));
}
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Binary op = bexpr.Operator;
Expression left = Simplify(bexpr.Left);
Expression right = Simplify(bexpr.Right);
if (left is NumberExpression && right is NumberExpression)
{
return(calculate(op, (NumberExpression)left, (NumberExpression)right));
}
else if (left is NumberExpression || right is NumberExpression)
{
double num;
Expression other;
bool isLeft = true;
if (left is NumberExpression)
{
num = ((NumberExpression)left).Value;
other = right;
}
else
{
isLeft = false;
num = ((NumberExpression)right).Value;
other = left;
}
if (num == 0 && op == Binary.Add ||
num == 0 && op == Binary.Subtract && !isLeft ||
num == 1 && op == Binary.Multiply ||
num == 1 && op == Binary.Divide && !isLeft ||
num == 1 && op == Binary.Power && !isLeft)
{
return(other);
}
if (num == 0 && op == Binary.Multiply ||
num == 0 && op == Binary.Divide && isLeft ||
num == 0 && op == Binary.Power && isLeft)
{
return(Expression.Number(0));
}
if (num == 0 && op == Binary.Power && !isLeft ||
num == 1 && op == Binary.Power && isLeft)
{
return(Expression.Number(1));
}
if (isLeft && op == Binary.Add)
{
return(Expression.Add(right, left));
}
if (!isLeft && op == Binary.Multiply)
{
return(Expression.Multiply(right, left));
}
}
else
{
if (op == Binary.Divide && left.Equals(right))
{
return(Expression.Number(1));
}
if (op == Binary.Subtract && left.Equals(right))
{
return(Expression.Number(0));
}
if (op == Binary.Add && right is BinaryExpression && ((BinaryExpression)right).Operator == Binary.Multiply && ((BinaryExpression)right).Left is NumberExpression && ((NumberExpression)((BinaryExpression)right).Left).Value == -1)
{
BinaryExpression bright = (BinaryExpression)right;
if (left.Equals(bright.Right))
{
return(Expression.Number(0));
}
}
}
return(Expression.FromBinary(bexpr.Operator, left, right));
}
else if (expr is LinearExpression)
{
LinearExpression lexpr = (LinearExpression)expr;
IList <Expression> list = new List <Expression>();
foreach (Expression item in lexpr.List)
{
list.Add(Simplify(item));
}
return(new LinearExpression(lexpr.Operator, list));
}
return(expr);
}
public IList <Token> Reverse(Expression expr, int top = -1)
{
IList <Token> tks = new List <Token>();
if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
IList <Token> leftTokens = Reverse(bexpr.Left, opToNum(bexpr.Operator));
IList <Token> rightTokens = Reverse(bexpr.Right, opToNum(bexpr.Operator));
bool brackets = false;
if (top > opToNum(bexpr.Operator) || (bexpr.Operator == Binary.Divide && top > 0))
{
brackets = true;
}
if (brackets)
{
tks.Add(new Token(Symbol.OpenRoundBracket));
}
addMany(tks, leftTokens);
tks.Add(new Token(opToSym(bexpr.Operator)));
addMany(tks, rightTokens);
if (brackets)
{
tks.Add(new Token(Symbol.CloseRoundBracket));
}
}
else if (expr is LinearExpression) // Mainly for debugging
{
LinearExpression lexpr = (LinearExpression)expr;
bool brackets = false;
if (top > opToNum(lexpr.Operator))
{
brackets = true;
}
if (brackets)
{
tks.Add(new Token(Symbol.OpenRoundBracket));
}
for (int i = 0; i < lexpr.List.Count; i++)
{
if (i > 0)
{
tks.Add(new Token(opToSym(lexpr.Operator)));
}
IList <Token> subTks = Reverse(lexpr[i], opToNum(lexpr.Operator));
addMany(tks, subTks);
}
if (brackets)
{
tks.Add(new Token(Symbol.CloseRoundBracket));
}
}
else if (expr is NumberExpression)
{
NumberExpression nexpr = (NumberExpression)expr;
double value = nexpr.Value;
if (value < 0)
{
tks.Add(new Token(Symbol.OpenRoundBracket));
}
tks.Add(new Token(Symbol.Number, value.ToString()));
if (value < 0)
{
tks.Add(new Token(Symbol.CloseRoundBracket));
}
}
else if (expr is VariableExpression)
{
VariableExpression vexpr = (VariableExpression)expr;
string name = vexpr.Name;
tks.Add(new Token(Symbol.Word, name));
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
string name = fexpr.Name;
tks.Add(new Token(Symbol.Word, name));
tks.Add(new Token(Symbol.OpenRoundBracket));
for (int i = 0; i < fexpr.Arguments.Count; i++)
{
if (i > 0)
{
tks.Add(new Token(Symbol.Comma));
}
IList <Token> argTks = Reverse(fexpr.Arguments[i]);
addMany(tks, argTks);
}
tks.Add(new Token(Symbol.CloseRoundBracket));
}
return(tks);
}