public double Apply(NumericVariable numericVariable, MembershipFunction msf)
{
if (msf.Count == 0)
return (numericVariable.MaxValue - numericVariable.MinValue) / 2.0;
if (msf[0].Y > 0 && msf[0].X > numericVariable.MinValue)
{
msf.Add(numericVariable.MinValue, msf[0].Y);
}
if (msf[msf.Count - 1].Y > 0 && msf[msf.Count - 1].X < numericVariable.MaxValue)
{
msf.Add(numericVariable.MaxValue, msf[msf.Count - 1].Y);
}
var numerator = 0d;
var denominator = 0d;
for (var i = 0; i < msf.Count - 1; i++)
{
var value1 = msf[i];
var value2 = msf[i + 1];
var min = Math.Min(value1.Y, value2.Y);
var max = Math.Max(value1.Y, value2.Y);
var line = new LineSegment(value1, value2);
var m = line.Gradient.Value;
var b = line.B.Value;
numerator += ((m / 3.0) * (Math.Pow(value2.X, 3) - Math.Pow(value1.X, 3))) + ((b / 2.0) * (Math.Pow(value2.X, 2) - Math.Pow(value1.X, 2)));
denominator += ((max + min) / 2.0) * (value2.X - value1.X);
}
return numerator / denominator;
}
public Point Intersect(LineSegment segment)
{
if (Start.Equals(segment.End))
return Start;
if (End.Equals(segment.Start))
return End;
if ( Gradient == segment.Gradient)
return null;
if (Gradient == null)
return intersectWithVertical(Start.X, segment);
if (segment.Gradient == null)
return intersectWithVertical(segment.Start.X, this);
if (Gradient == 0)
return intersectWithHorizontal(Start.Y, segment);
if (segment.Gradient == 0)
return intersectWithHorizontal(segment.Start.Y, this);
var b1 = Start.Y - Start.X * Gradient.Value;
var b2 = segment.Start.Y - segment.Start.X * segment.Gradient.Value;
var x = (b1 - b2)/(segment.Gradient.Value - Gradient.Value);
var y = Gradient.Value*x + b1;
var point = new Point(x, y);
if (Contains(point) && segment.Contains(point))
return point;
return null;
}
public void Intersects_2b()
{
var sut = new LineSegment(new Point(0, 0), new Point(4, 4));
var result = sut.Intersect(new LineSegment(new Point(-2, 4), new Point(0, 0)));
Assert.AreEqual(new Point(0, 0), result);
}
public void Constructor()
{
var sut = new LineSegment(new Point(0, 0), new Point(2, 2));
Assert.AreEqual(new Point(0, 0), sut.Start);
Assert.AreEqual(new Point(2, 2), sut.End);
Assert.AreEqual(1 , sut.Gradient);
}
public void Contains_Point()
{
var sut = new LineSegment(new Point(0, 0), new Point(2, 2));
Assert.IsTrue(sut.Contains(new Point(0, 0)));
Assert.IsTrue(sut.Contains(new Point(1, 1)));
Assert.IsTrue(sut.Contains(new Point(2, 2)));
}
public void Does_Not_Contain_Point()
{
var sut = new LineSegment(new Point(0, 0), new Point(2, 2));
Assert.IsFalse(sut.Contains(new Point(-1, -1)));
Assert.IsFalse(sut.Contains(new Point(3, 3)));
Assert.IsFalse(sut.Contains(new Point(3, 0)));
Assert.IsFalse(sut.Contains(new Point(1, 2)));
}
private static Point intersectWithHorizontal(double y, LineSegment segment)
{
if (y < Math.Min(segment.Start.Y, segment.End.Y) || y > Math.Max(segment.Start.Y, segment.End.Y))
return null;
var b = segment.Start.Y - segment.Start.X*segment.Gradient.Value;
var x = (y - b) / segment.Gradient.Value;
return new Point(x, y);
}
private static Point intersectWithVertical(double x, LineSegment segment)
{
if (x < Math.Min(segment.Start.X, segment.End.X) || x > Math.Max(segment.Start.X, segment.End.X))
return null;
var b = segment.Start.Y - segment.Start.X*segment.Gradient.Value;
var y = segment.Gradient.Value*x + b;
return new Point(x, y);
}
private static MembershipFunction combine(MembershipFunction first, MembershipFunction second)
{
if (!first.Any())
return second;
if (!second.Any())
return first;
var scanPoints = getScanPoints(first, second);
var result = new MembershipFunction();
for (var i = 0; i < scanPoints.Count; i++)
{
var scanPoint = scanPoints[i];
var valueFirst = first.Apply(scanPoint);
var valueSecond = second.Apply(scanPoint);
result.Add(scanPoint, Math.Max(valueFirst, valueSecond));
// Check if there is an intersection between this scan point and the next
// and add it to the list of scan points:
var nextKeyFirst = getNextKey(first, scanPoint);
var nextKeySecond = getNextKey(second, scanPoint);
if (nextKeyFirst.HasValue && nextKeySecond.HasValue)
{
var nextValueFirst = first[nextKeyFirst.Value];
var nextValueSecond = second[nextKeySecond.Value];
if (valueFirst >= valueSecond && nextValueFirst < nextValueSecond ||
valueFirst < valueSecond && nextValueFirst >= nextValueSecond)
{
var lineFirst = new LineSegment(new Point(scanPoint, valueFirst),
new Point(nextKeyFirst.Value, nextValueFirst));
var lineSecond = new LineSegment(new Point(scanPoint, valueSecond),
new Point(nextKeySecond.Value, nextValueSecond));
var intersection = lineFirst.Intersect(lineSecond);
if (intersection != null && !scanPoints.Contains(intersection.X) && intersection.X > scanPoint)
scanPoints.Insert(i + 1, intersection.X);
}
}
}
return result.ClearUp();
}
public void ToStringTest()
{
var sut = new LineSegment(new Point(0, 0), new Point(2, 2));
Assert.AreEqual("(0;0) -> (2;2)", sut.ToString());
}
public void Dont_Intersects_6()
{
var sut = new LineSegment(new Point(0, 0), new Point(4, 4));
var result = sut.Intersect(new LineSegment(new Point(5, 0), new Point(5, 5)));
Assert.IsNull(result);
}
public void Intersects_7()
{
var sut = new LineSegment(new Point(3, 0.5), new Point(5, 0.5));
var result = sut.Intersect(new LineSegment(new Point(3, 0.5), new Point(4, 1)));
Assert.AreEqual(new Point(3, 0.5), result);
}
public void Intersects_5()
{
var line1 = new LineSegment(new Point(0, 0), new Point(4, 4));
var line2 = new LineSegment(new Point(3, 0), new Point(3, 6));
Assert.AreEqual(new Point(3, 3), line1.Intersect(line2));
Assert.AreEqual(new Point(3, 3), line2.Intersect(line1));
}
