public override int GetHashCode()
{
unchecked
{
return(((XColumn?.GetHashCode() ?? 0) * 397) ^ (YColumn?.GetHashCode() ?? 0));
}
}
private void Remove(XColumn column)
{
if (column == null)
{
return;
}
column.PropertyChanged -= ObserveColumn;
}
private void Add(XColumn column)
{
if (column == null)
{
return;
}
column.PropertyChanged += ObserveColumn;
}
/// <summary>
/// Add column to database columns collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="db">The database instance.</param>
/// <param name="column">The column instance.</param>
public static void AddColumn(this XProject project, XDatabase db, XColumn column)
{
if (db?.Columns != null && column != null)
{
var previous = db.Columns;
var next = db.Columns.Add(column);
project?.History?.Snapshot(previous, next, (p) => db.Columns = p);
db.Columns = next;
}
}
/// <summary>
/// Remove column from database columns collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="column">The <see cref="XColumn"/> to remove.</param>
public static void RemoveColumn(this XProject project, XColumn column)
{
var db = column?.Owner;
if (db != null && db.Columns != null)
{
var previous = db.Columns;
var next = db.Columns.Remove(column);
project?.History?.Snapshot(previous, next, (p) => db.Columns = p);
db.Columns = next;
}
}
public InternalSolution Solve()
{
// first thing's first!
if (!IsStandardized)
{
try
{
Standardize();
}
catch
{
var effff = SolutionHelper.Infeasible();
return(new InternalSolution(effff, this));
}
}
// Loop over finding new basic variables until terminating conditions found
for (var badUniqueVariableName = 0; badUniqueVariableName < 300; badUniqueVariableName++)
{
// create matrix of basics
var basicInverse = DenseMatrix.OfColumnVectors(PColumns.Where(p => p.IsBasic).ToArray()).Inverse();
// compute product of inverse and RHS values
var xPrime = DenseVector.OfEnumerable((basicInverse * (XColumn.ToColumnMatrix())).ToColumnWiseArray().Select(x => Math.Round(x, 6)));
var pPrimes = new List <PVectorPrime>();
var zCoefs = DenseVector.OfEnumerable(PColumns.Where(p => p.IsBasic).Select(p => p.ZValue));
foreach (var col in PColumns.Where(p => !p.IsBasic))
{
//was getting some weird precision issues... so chop 'em short
var pPrime = DenseVector.OfEnumerable((basicInverse * col.ToColumnMatrix()).ToColumnWiseArray().Select(x => Math.Round(x, 6)));
var cPrime = Math.Round(col.ZValue - (zCoefs * pPrime), 6);
pPrimes.Add(new PVectorPrime(col, pPrime, cPrime));
}
//var anyNegative = cPrimes.Any(x => x < 0);
var anyNegative = pPrimes.Any(x => Math.Round(x.CPrime, 2) < 0);
if (anyNegative)
{
PVector entering, exiting = null;
// determine entering basic variable (using Bland's method. inefficient, but reliable)
var tempPrime = pPrimes.First(p => Math.Round(p.CPrime, 4) < 0);
entering = tempPrime.PColumn;
// compute ratio of x prime to p prime assosiated with new basic variable
var ratios = (xPrime / tempPrime.PColumnPrime).Select(x => Math.Round(x, 6)).ToList();
// make sure there are positives, if not, then the entire problem unbounded
var anyPositive = ratios.Any(x => x > 0 && !double.IsInfinity(x));
if (anyPositive)
{
var min = ratios.Min(x => x > 0 ? x : double.PositiveInfinity);
var minIndexes = Enumerable.Range(0, ratios.Count).Where(i => ratios[i] == min).ToArray();
if (minIndexes.Length > 1)
{
var potentialExits = PColumns.Where(p => p.IsBasic).Where((x, i) => minIndexes.Contains(i));
var artificalCount = PColumns.Count(p => p.IsArtificial);
exiting = potentialExits.OrderByDescending(p => PColumns.Skip(PColumns.Count - artificalCount).Take(artificalCount - 1).Contains(p)).First();
}
else
{
exiting = PColumns.Where(p => p.IsBasic).ElementAt(minIndexes[0]);
}
}
else
{
var anyPositiveOrZeros = ratios.Any(x => x >= 0 && !double.IsInfinity(x));
if (anyPositiveOrZeros)
{
var min = ratios.Min(x => x >= 0 ? x : double.PositiveInfinity);
var minIndexes = Enumerable.Range(0, ratios.Count).Where(i => ratios[i] == min).ToArray();
if (minIndexes.Length > 1)
{
var potentialExits = PColumns.Where(p => p.IsBasic).Where((x, i) => minIndexes.Contains(i));
var artificalCount = PColumns.Count(p => p.IsArtificial);
exiting = potentialExits.OrderByDescending(p => PColumns.Skip(PColumns.Count - artificalCount).Take(artificalCount - 1).Contains(p)).First();
}
else
{
exiting = PColumns.Where(p => p.IsBasic).ElementAt(minIndexes[0]);
}
}
else
{
return(new InternalSolution(SolutionHelper.Unbounded()));
}
}
// actually change the basic-ness
entering.IsBasic = true;
exiting.IsBasic = false;
}
// infeasible
else if (PColumns.Any(p => p.IsArtificial && p.IsBasic))
{
return(new InternalSolution(SolutionHelper.Infeasible(), this));
}
// optimal
else
{
var targetNumDecisions = Goal.Coefficients.Length;
var decisions = new List <double>();
var xIndex = 0;
foreach (var p in PColumns.Where(x => x.IsDecision))
{
if (p.IsBasic)
{
decisions.Add(xPrime[xIndex]);
xIndex++;
}
else
{
decisions.Add(0);
}
}
var value = decisions.Select((x, i) => x * Goal.Coefficients[i]).Sum();
value += Goal.ConstantTerm;
var allPPrimes = new List <PVectorPrime>();
foreach (var col in PColumns)
{
//was getting some weird precision issues... so chop 'em short
var pPrime = DenseVector.OfEnumerable((basicInverse * col.ToColumnMatrix()).ToColumnWiseArray());
var cPrime = Math.Round(col.ZValue - (zCoefs * pPrime), 6);
allPPrimes.Add(new PVectorPrime(col, pPrime, cPrime));
}
var infiniteSols = pPrimes.Count(p => Math.Round(p.CPrime, 4) == 0) >= Goal.Coefficients.Length;
var sol = SolutionHelper.Optimal(decisions.ToArray(), value, infiniteSols);
return(new InternalSolution(sol, this));
}
}
var uhoh = SolutionHelper.TimedOut();
return(new InternalSolution(uhoh, this));
}
/// <inheritdoc/>
XProject IProjectFactory.GetProject()
{
var factory = this as IProjectFactory;
var project = XProject.Create();
// Group Libraries
var glBuilder = project.GroupLibraries.ToBuilder();
glBuilder.Add(XLibrary <XGroup> .Create("Default"));
project.GroupLibraries = glBuilder.ToImmutable();
project.SetCurrentGroupLibrary(project.GroupLibraries.FirstOrDefault());
// Style Libraries
var sgBuilder = project.StyleLibraries.ToBuilder();
sgBuilder.Add(DefaultStyleLibrary());
sgBuilder.Add(LinesStyleLibrary());
sgBuilder.Add(TemplateStyleLibrary());
project.StyleLibraries = sgBuilder.ToImmutable();
project.SetCurrentStyleLibrary(project.StyleLibraries.FirstOrDefault());
// Templates
var templateBuilder = project.Templates.ToBuilder();
templateBuilder.Add(factory.GetTemplate(project, "Empty"));
templateBuilder.Add(CreateGridTemplate(this, project, "Grid"));
project.Templates = templateBuilder.ToImmutable();
project.SetCurrentTemplate(project.Templates.FirstOrDefault(t => t.Name == "Grid"));
// Documents and Pages
var document = factory.GetDocument(project, "Document");
var page = factory.GetPage(project, "Page");
var pageBuilder = document.Pages.ToBuilder();
pageBuilder.Add(page);
document.Pages = pageBuilder.ToImmutable();
var documentBuilder = project.Documents.ToBuilder();
documentBuilder.Add(document);
project.Documents = documentBuilder.ToImmutable();
project.Selected = document.Pages.FirstOrDefault();
// Databases
var db = XDatabase.Create("Db");
var columnsBuilder = db.Columns.ToBuilder();
columnsBuilder.Add(XColumn.Create(db, "Column0"));
columnsBuilder.Add(XColumn.Create(db, "Column1"));
db.Columns = columnsBuilder.ToImmutable();
project.Databases = project.Databases.Add(db);
project.SetCurrentDatabase(db);
return(project);
}
public void Inherits_From_ObservableObject()
{
var target = new XColumn();
Assert.True(target is ObservableObject);
}
/// <summary>
/// Initializes static designer context.
/// </summary>
/// <param name="renderer">The design time renderer instance.</param>
/// <param name="clipboard">The design time clipboard instance.</param>
/// <param name="jsonSerializer">The design time Json serializer instance.</param>
/// <param name="xamlSerializer">The design time Xaml serializer instance.</param>
/// <returns>The new instance of the <see cref="DesignerContext"/> class.</returns>
public static void InitializeContext(ShapeRenderer renderer, ITextClipboard clipboard, ITextSerializer jsonSerializer, ITextSerializer xamlSerializer)
{
// Editor
Editor = new ProjectEditor()
{
CurrentTool = Tool.Selection,
CurrentPathTool = PathTool.Line,
CommandManager = new DesignerCommandManager(),
Renderers = new ShapeRenderer[] { renderer },
ProjectFactory = new ProjectFactory(),
TextClipboard = clipboard,
JsonSerializer = jsonSerializer,
XamlSerializer = xamlSerializer
}.Defaults();
// Recent Projects
Editor.RecentProjects = Editor.RecentProjects.Add(RecentFile.Create("Test1", "Test1.project"));
Editor.RecentProjects = Editor.RecentProjects.Add(RecentFile.Create("Test2", "Test2.project"));
// Commands
Editor.InitializeCommands();
InitializeCommands(Editor);
Editor.CommandManager.RegisterCommands();
// New Project
Editor.OnNew(null);
// Data
var db = XDatabase.Create("Db");
var fields = new string[] { "Column0", "Column1" };
var columns = ImmutableArray.CreateRange(fields.Select(c => XColumn.Create(db, c)));
db.Columns = columns;
var values = Enumerable.Repeat("<empty>", db.Columns.Length).Select(c => XValue.Create(c));
var record = XRecord.Create(
db,
db.Columns,
ImmutableArray.CreateRange(values));
db.Records = db.Records.Add(record);
db.CurrentRecord = record;
Database = db;
Data = XContext.Create(record);
Record = record;
// Project
IProjectFactory factory = new ProjectFactory();
Project = factory.GetProject();
Template = XContainer.CreateTemplate();
Page = XContainer.CreatePage();
var layer = Page.Layers.FirstOrDefault();
layer.Shapes = layer.Shapes.Add(XLine.Create(0, 0, null, null));
Page.CurrentLayer = layer;
Page.CurrentShape = layer.Shapes.FirstOrDefault();
Page.Template = Template;
Document = XDocument.Create();
Layer = XLayer.Create();
Options = XOptions.Create();
// State
State = ShapeState.Create();
// Style
ArgbColor = ArgbColor.Create();
ArrowStyle = ArrowStyle.Create();
FontStyle = FontStyle.Create();
LineFixedLength = LineFixedLength.Create();
LineStyle = LineStyle.Create();
Style = ShapeStyle.Create("Default");
TextStyle = TextStyle.Create();
// Shapes
Arc = XArc.Create(0, 0, Style, null);
CubicBezier = XCubicBezier.Create(0, 0, Style, null);
Ellipse = XEllipse.Create(0, 0, Style, null);
Group = XGroup.Create(Constants.DefaulGroupName);
Image = XImage.Create(0, 0, Style, null, "key");
Line = XLine.Create(0, 0, Style, null);
Path = XPath.Create("Path", Style, null);
Point = XPoint.Create();
QuadraticBezier = XQuadraticBezier.Create(0, 0, Style, null);
Rectangle = XRectangle.Create(0, 0, Style, null);
Text = XText.Create(0, 0, Style, null, "Text");
// Path
ArcSegment = XArcSegment.Create(XPoint.Create(), XPathSize.Create(), 180, true, XSweepDirection.Clockwise, true, true);
CubicBezierSegment = XCubicBezierSegment.Create(XPoint.Create(), XPoint.Create(), XPoint.Create(), true, true);
LineSegment = XLineSegment.Create(XPoint.Create(), true, true);
PathFigure = XPathFigure.Create(XPoint.Create(), false, true);
PathGeometry = XPathGeometry.Create(ImmutableArray.Create <XPathFigure>(), XFillRule.EvenOdd);
PathSize = XPathSize.Create();
PolyCubicBezierSegment = XPolyCubicBezierSegment.Create(ImmutableArray.Create <XPoint>(), true, true);
PolyLineSegment = XPolyLineSegment.Create(ImmutableArray.Create <XPoint>(), true, true);
PolyQuadraticBezierSegment = XPolyQuadraticBezierSegment.Create(ImmutableArray.Create <XPoint>(), true, true);
QuadraticBezierSegment = XQuadraticBezierSegment.Create(XPoint.Create(), XPoint.Create(), true, true);
}
