public void FirstArgumentIsZero_GetDerivative_ResultMustBeZero()
{
var coefficientsLinearFunction = new LinearFunction(0, 3);
Assert.AreEqual(coefficientsLinearFunction.GetDerivative().ToString(), "0");
}
public void SetsSlope(double slope)
{
var line = new LinearFunction(slope, 1.0);
var otherLine = new LinearFunction(line);
Assert.AreEqual(slope, otherLine.Slope);
}
public void Gradient()
{
var f = new LinearFunction <double>();
var grad = f.Gradient(new Vector <double>(new[] { 2d }),
new Vector <double>(new double[0])).ToArray();
Assert.Single(grad);
Assert.True(1e-14 > Math.Abs(1 - grad[0]));
grad = f.Gradient(new Vector <double>(new[] { 2d, 1d }),
new Vector <double>(new[] { 2d })).ToArray();
Assert.True(grad.Length == 2);
Assert.True(1e-14 > Math.Abs(2 - grad[0]));
Assert.True(1e-14 > Math.Abs(1 - grad[1]));
grad = f.Gradient(new Vector <double>(new[] { 2d, 3d, 1d }),
new Vector <double>(new[] { 2d, 3d })).ToArray();
Assert.True(grad.Length == 3);
Assert.True(1e-14 > Math.Abs(2 - grad[0]));
Assert.True(1e-14 > Math.Abs(3 - grad[1]));
Assert.True(1e-14 > Math.Abs(1 - grad[2]));
}
public void VariableIsZero_Calculate_ResultMustBeNumber()
{
var coefficientsLinearFunction = new LinearFunction(-3.1, 2.1);
Assert.AreEqual(coefficientsLinearFunction.Calculate(0), 2.1, 0.1);
}
public void FirstArgumentIsZero_ToString_ResultMustBeZero()
{
var coefficientsLinearFunction = new LinearFunction(0, 3);
Assert.AreEqual(coefficientsLinearFunction.ToString(), "3");
}
public void FirstArgumentOfNegative_GetDerivative_ResultMustBeNumber()
{
var coefficientsLinearFunction = new LinearFunction(-3.2, 3);
Assert.AreEqual(coefficientsLinearFunction.GetDerivative().ToString(), "-3,2x");
}
public void SecondArgumentIsZero_ToString_ResultMustBeZero()
{
var coefficientsLinearFunction = new LinearFunction(3, 0);
Assert.AreEqual(coefficientsLinearFunction.ToString(), "3x");
}
public void ArgumentsAreNegative_ToString_ResultMustBeNumber()
{
var coefficientsLinearFunction = new LinearFunction(-3, -2.3);
Assert.AreEqual(coefficientsLinearFunction.ToString(), "-3x -2,3");
}
public void SetsYIntersect(double yIntersect)
{
var line = new LinearFunction(1.0, yIntersect);
var otherLine = new LinearFunction(line);
Assert.AreEqual(yIntersect, otherLine.YIntersect);
}
public void TwoArgumentsAreZero_Calculate_ResultMustBeZero()
{
var coefficientsLinearFunction = new LinearFunction(0, 0);
Assert.Zero(coefficientsLinearFunction.Calculate(2));
}
/// <summary>
/// Private constructor
/// </summary>
private Inequality(Label id, IneqType type, LinearFunction lhs, LpNumber rhs, bool negFlag)
{
this.Id = id;
this.type = type;
this.lhs = lhs;
this.rhs = rhs;
this.NegFlag = negFlag;
}
public void TwoArgumentAreZero_GetDerivative_ResultMustBeZero()
{
var coefficientsLinearFunction = new LinearFunction(0, 0);
var result = coefficientsLinearFunction.GetDerivative();
Assert.AreEqual(result.ToString(), "0");
}
public void Value()
{
var f = new LinearFunction <double>();
var point1 = new Vector <double>(new double[0]);
var point2 = new Vector <double>(new[] { 2d });
var point3 = new Vector <double>(new[] { 3d });
var functional = new L1Functional <double>(new[]
public void GetsTheRightValue(double slope, double yIntersect, double xValue, double yValue)
{
var function = new LinearFunction(slope, yIntersect);
var x = function.GetXValue(yValue);
Assert.AreEqual(xValue, x);
}
public void TestTransfer()
{
LinearFunction trans
= LinearFunction.Instance;
Assert.AreEqual(0, trans.Activate(0));
Assert.AreEqual(-1, trans.Activate(-1));
Assert.AreEqual(1, trans.Activate(1));
}
public void ReturnsNullForParallelLines(double slope, double yIntersect1, double yIntersect2)
{
var line1 = new LinearFunction(slope, yIntersect1);
var line2 = new LinearFunction(slope, yIntersect2);
var intersection = line1.GetIntersection(line2);
Assert.IsNull(intersection);
}
public void ExcludesPieceEntirelyOverNegativeLine()
{
var line = new LinearFunction(-1.0, -2.0);
var result = line >= this.stepDownIncludeUpper;
Assert.AreEqual(0.0, result.GetValue(0.0));
Assert.AreEqual(0.0, result.GetValue(0.5));
Assert.AreEqual(0.0, result.GetValue(1.0));
}
public void IncludesPieceEntirelyUnderNegativeLine()
{
var line = new LinearFunction(-1.0, 2.5);
var result = line >= this.stepUpIncludeUpper;
Assert.AreEqual(1.0, result.GetValue(0.0));
Assert.AreEqual(1.0, result.GetValue(0.5));
Assert.AreEqual(1.0, result.GetValue(1.0));
}
public void IncludesPieceEntirelyUnderPositiveLine()
{
var line = new LinearFunction(1.0, 4.0);
var result = line > this.stepDownIncludeUpper;
Assert.AreEqual(1.0, result.GetValue(0.0));
Assert.AreEqual(1.0, result.GetValue(0.5));
Assert.AreEqual(1.0, result.GetValue(1.0));
}
public void LinearFunction_GetDerivative_ResultMustBeNumber()
{
var linearFunction = new LinearFunction(2.1, 5);
var name = "LinearFunction";
var storage = new FunctionsStorage();
storage.AddFunction(name, linearFunction);
Assert.AreEqual(storage.GetDerivativeFunction(name).ToString(), "2,1x");
}
public void ReturnsCorrectValueWhenIntersectionExists(bool includeLeft, bool includeRight, double lower, double upper, double value, double yIntersect, double slope, double expected)
{
var piece = new PiecewiseFunction.Piece {
UpperBound = upper, Value = value, IncludeUpperBound = includeRight
};
var function = new LinearFunction(slope, yIntersect);
var intersect = piece.GetIntersect(function, lower, includeLeft);
Assert.IsTrue(intersect.HasValue);
Assert.AreEqual(expected, intersect.Value);
}
public void CorrectlyDividesDouble(double firstSlope, double firstYIntersect, double second, double expectedResultSlope, double expectedResultYIntersect)
{
// Arrange
var first = new LinearFunction(firstSlope, firstYIntersect);
// Act
var result = first / second;
// Assert
Assert.NotNull(result);
Assert.AreEqual(expectedResultSlope, result.Slope);
Assert.AreEqual(expectedResultYIntersect, result.YIntersect);
}
public void HandlesNegativeLinearFunctionAtIncludedUpperBound()
{
var twoMinusX = new LinearFunction(-1.0, 2.0);
var result = twoMinusX >= this.stepUpIncludeUpper;
Assert.AreEqual(1.0, result.GetValue(0.0));
Assert.AreEqual(1.0, result.GetValue(0.5));
Assert.AreEqual(1.0, result.GetValue(0.999));
Assert.AreEqual(1.0, result.GetValue(1.0));
Assert.AreEqual(0.0, result.GetValue(1.0001));
Assert.AreEqual(0.0, result.GetValue(1.5));
}
public void HandlesPositiveLinearFunctionAtIncludedLowerBound()
{
var zeroPlusX = new LinearFunction(1.0, 0.0);
var result = zeroPlusX >= this.stepDownIncludeLower;
Assert.AreEqual(0.0, result.GetValue(0.0));
Assert.AreEqual(0.0, result.GetValue(0.5));
Assert.AreEqual(0.0, result.GetValue(0.999));
Assert.AreEqual(1.0, result.GetValue(1.0));
Assert.AreEqual(1.0, result.GetValue(1.0001));
Assert.AreEqual(1.0, result.GetValue(1.5));
}
public void HandlesPositiveLinearFunctionAtIncludedUpperBound()
{
var onePlusX = new LinearFunction(1.0, 0.0);
var result = onePlusX >= this.stepUpIncludeUpper;
Assert.AreEqual(0.0, result.GetValue(0.0));
Assert.AreEqual(0.0, result.GetValue(0.5));
Assert.AreEqual(0.0, result.GetValue(0.999));
Assert.AreEqual(1.0, result.GetValue(1.0));
Assert.AreEqual(0.0, result.GetValue(1.0001));
Assert.AreEqual(0.0, result.GetValue(1.5));
}
public void CorrectlySubtractsLinearFunction(double firstSlope, double firstYIntersect, double secondSlope, double secondYIntersect, double expectedResultSlope, double expectedResultYIntersect)
{
// Arrange
var first = new LinearFunction(firstSlope, firstYIntersect);
var second = new LinearFunction(secondSlope, secondYIntersect);
// Act
var result = first - second;
// Assert
Assert.NotNull(result);
Assert.AreEqual(expectedResultSlope, result.Slope);
Assert.AreEqual(expectedResultYIntersect, result.YIntersect);
}
public void IncludesBeforeNegativeLineIntersectsMiddleOfPiece()
{
var line = new LinearFunction(-1.0, 2.0);
var result = line > this.constantOne;
Assert.AreEqual(1.0, result.GetValue(0.0));
Assert.AreEqual(1.0, result.GetValue(0.5));
Assert.AreEqual(1.0, result.GetValue(0.99999));
Assert.AreEqual(0.0, result.GetValue(1.0));
Assert.AreEqual(0.0, result.GetValue(2.0));
Assert.AreEqual(0.0, result.GetValue(1000.0));
Assert.AreEqual(0.0, result.GetValue(double.MaxValue));
}
public void IncludesAfterAndWhenPositiveLineIntersectsMiddleOfPiece()
{
var line = new LinearFunction(1.0, 0.0);
var result = line >= this.constantOne;
Assert.AreEqual(0.0, result.GetValue(0.0));
Assert.AreEqual(0.0, result.GetValue(0.5));
Assert.AreEqual(0.0, result.GetValue(0.99999));
Assert.AreEqual(1.0, result.GetValue(1.0));
Assert.AreEqual(1.0, result.GetValue(1.0001));
Assert.AreEqual(1.0, result.GetValue(2.0));
Assert.AreEqual(1.0, result.GetValue(1000.0));
Assert.AreEqual(1.0, result.GetValue(double.MaxValue));
}
public void ReturnsCorrectAnswerForNonParallelLines(
double slope1,
double intersect1,
double slope2,
double intersect2,
double expectedValue)
{
var line1 = new LinearFunction(slope1, intersect1);
var line2 = new LinearFunction(slope2, intersect2);
var intersection = line1.GetIntersection(line2);
Assert.IsNotNull(intersection);
Assert.AreEqual(expectedValue, intersection.Value);
}
public ICommand BuildCommand(string input)
{
var regexForName = new Regex(@"\w+");
var regexForArguments = new Regex(@"(-?\d+(,\d+)?)");
var regForFunction = new Regex(@"\w+\((-?\d+(,\d+)?) (-?\d+(,\d+)?)\)$");
var regexForParameters = new Regex(@"\((-?\d+(,\d+)?) (-?\d+(,\d+)?)\)$");
var function = regForFunction.Match(input).ToString();
var name = regexForName.Match(function).ToString();
var parameters = regexForParameters.Match(function).ToString();
var arguments = regexForArguments.Matches(parameters);
var firstArgument = Convert.ToDouble(arguments[0].ToString());
var secondArgument = Convert.ToDouble(arguments[1].ToString());
var linearFunction = new LinearFunction(firstArgument, secondArgument);
return(new AddFunctionCommand(name, linearFunction));
}
public void Value()
{
var f = new LinearFunction <double>();
Assert.True(1e-14 > Math.Abs(2 - f.Value(new Vector <double>(new[] { 2d }),
new Vector <double>(new double[0]))));
Assert.True(1e-14 > Math.Abs(3 - f.Value(new Vector <double>(new[] { 3d }),
new Vector <double>(new double[0]))));
Assert.True(1e-14 > Math.Abs(7 - f.Value(new Vector <double>(new[] { 3d, 1d }),
new Vector <double>(new[] { 2d }))));
Assert.True(1e-14 > Math.Abs(10 - f.Value(new Vector <double>(new[] { 3d, 1d }),
new Vector <double>(new[] { 3d }))));
}
private void ScaleHeights(float L)
{
label label = new label(SetToolStripLabel);
progres progres = new progres(SetProgressBar);
form.statusStrip1.Invoke(label, "Prebieha škálovanie výšok...");
LinearFunction map_z;
LinearFunction percenta = new LinearFunction(50.0f, 1.0f, 0.5f, 0.01f);
if((maxX-minX)>(maxY-minY))
map_z = new LinearFunction(min, max, 0, (maxX - minX) * percenta.Value(L));
else
map_z = new LinearFunction(min, max, 0, (maxY - minY) * percenta.Value(L));
//System.Diagnostics.Debug.WriteLine("[{0},{1}]",map_z.Value(min),map_z.Value(max));
//System.Windows.Forms.MessageBox.Show("["+map_z.Value(min)+","+map_z.Value(max)+"]");
int d = coords.Count / 100;
float dx = minX + (maxX - minX) / 2.0f;
float dy = minY + (maxY - minY) / 2.0f;
for (int i = 0; i < coords.Count; i++)
{
//vertices[i] = new Vector3( -coords[i].X + dx, coords[i].Y - dy, coords[i].Z / (L * dl) - dz / (L * dl));
vertices[i] = new Vector3(-coords[i].X + dx, coords[i].Y - dy, map_z.Value(coords[i].Z));
if (i % d == 0)
form.statusStrip1.Invoke(progres, i * 100 / coords.Count);
}
}
public Vector3 SetColor(float height)
{
float dv = max - min;
Vector3 col = new Vector3();
for (int i = 1; i < keys.Length; i++)
{
if (height <= min + keys[i] * dv)
{
LinearFunction R = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].X, cm[keys[i]].X);
LinearFunction G = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].Y, cm[keys[i]].Y);
LinearFunction B = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].Z, cm[keys[i]].Z);
col = new Vector3(R.Value(height), G.Value(height), B.Value(height));
return col;
}
}
return col;
}
public Vector3[] SetColorArray(Vector3[] heights)
{
Vector3[] colors = new Vector3[heights.Length];
Vector3 col = new Vector3();
float dv = max - min;
for (int j = 0; j < heights.Length; j++)
{
for (int i = 1; i < keys.Length; i++)
{
if (heights[j].Z < min + keys[i] * dv)
{
LinearFunction R = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].X, cm[keys[i]].X);
LinearFunction G = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].Y, cm[keys[i]].Y);
LinearFunction B = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].Z, cm[keys[i]].Z);
col = new Vector3(R.Value(heights[j].Z), G.Value(heights[j].Z), B.Value(heights[j].Z));
i = keys.Length;
}
}
colors[j] = col;
}
return colors;
}
public List<Vector3> SetColorList(List<Vector3> heights)
{
List<Vector3> colors = new List<Vector3>();
Vector3 col = new Vector3();
float dv = max - min;
for (int j = 0; j < heights.Count; j++)
{
for (int i = 1; i < keys.Length; i++)
{
if (heights[j].Z < min + keys[i] * dv)
{
LinearFunction R = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].X, cm[keys[i]].X);
LinearFunction G = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].Y, cm[keys[i]].Y);
LinearFunction B = new LinearFunction(min + keys[i - 1] * dv, min + keys[i] * dv, cm[keys[i - 1]].Z, cm[keys[i]].Z);
col = new Vector3(R.Value(heights[j].Z), G.Value(heights[j].Z), B.Value(heights[j].Z));
i = keys.Length;
}
}
colors.Add(col);
}
return colors;
}
/// <summary>
/// Returns the equality 0 = 0
/// </summary>
public static Inequality Zero()
{
Label id = new Label("ZERO", "");
LinearFunction lhs = new LinearFunction(new List<decimal>(), new List<string>());
LpNumber rhs = new LpNumber(0);
Inequality ineq = new Inequality(id, IneqType.Eq, lhs, rhs, false);
return ineq;
}
/// <summary>
/// Generates a test file
/// </summary>
static void GenerateExamples()
{
FileStream fs = new FileStream("examples.hl", FileMode.Create);
StreamWriter w = new StreamWriter(fs);
Random rnd = new Random(2);
// Dependencies
w.WriteLine("needs \"test_explicit.hl\"");
w.WriteLine("let test = [");
for (int k = 0; k < 300; k++)
{
List<decimal> cs = new List<decimal>();
List<string> vars = new List<string>();
int i = rnd.Next(100);
while (i >= 0)
{
vars.Add('x'.ToString() + "_" + String.Format("{0:000}", i));
cs.Add(rnd.Next(1000000000));
i -= rnd.Next(10) + 1;
}
LinearFunction f = new LinearFunction(cs, vars);
w.Write(f.ToHOLExplicit(5, null));
// w.Write("`" + f.ToHOLString(5) + "`");
w.WriteLine(";");
}
w.WriteLine("];;");
w.Flush();
fs.Close();
}
