public static ValueTerm IntegrateTrapezoid(FunctionTerm function, OrderedRange <double> bounds, int segmentCount)
{
if (segmentCount < 1)
{
throw new ArgumentOutOfRangeException("segmentCount");
}
ValueTerm segmentWidth = Terms.Constant(bounds.Length() / segmentCount);
IEnumerable <ValueTerm> values =
(
from segmentPosition in Scalars.GetIntermediateValuesSymmetric(bounds.Start, bounds.End, segmentCount)
select function.Apply(Terms.Constant(segmentPosition))
)
.ToArray();
return(Terms.Product
(
segmentWidth,
Terms.Sum
(
Enumerables.Concatenate
(
Enumerables.Create(Terms.Product(Terms.Constant(0.5), values.First())),
values.Skip(1).SkipLast(1),
Enumerables.Create(Terms.Product(Terms.Constant(0.5), values.Last()))
)
)
));
}
BitField(bool[] bits)
{
if (bits == null)
{
throw new ArgumentNullException("bits");
}
this.bits = bits;
this.range = new OrderedRange <int>(0, bits.Length);
}
public void Should_CheckOverlaps(OrderedRange a, OrderedRange b, bool expected)
{
// Arrange
// Act
var result = a.OverlapsWith(b);
// Assert
result.Should().Be(expected);
}
public void Should_CalculateLengthCorrectly(int start, int end, int expected)
{
// Arrange
var range = new OrderedRange(start, end);
// Act
var result = range.Length;
// Assert
result.Should().Be(expected);
}
public void Should_StartWithSmaller_EndsWithLarger(int start, int end)
{
// Arrange
var range = new OrderedRange(start, end);
// Act
// Assert
range.Start.Should().BeLessOrEqualTo(range.End);
}
BitField(bool[] bits, OrderedRange <int> range)
{
if (bits == null)
{
throw new ArgumentNullException("bits");
}
if (range.Start < 0 || range.End > bits.Length)
{
throw new ArgumentOutOfRangeException("range");
}
this.bits = bits;
this.range = range;
}
public BitField this[OrderedRange <int> subRange]
{
get
{
subRange = new OrderedRange <int>(subRange.Start + range.Start, subRange.End + range.Start);
if (subRange.Start < range.Start || subRange.End > range.End)
{
throw new ArgumentException("subRange");
}
return(new BitField(bits, subRange));
}
}
static Krach.Graphics.Color StretchColor(double stretchFactor)
{
Krach.Graphics.Color baseColor = Krach.Graphics.Color.FromHsv(0, 0, 0);
OrderedRange <double> source = new OrderedRange <double>(0.75, 1.0);
OrderedRange <double> destination = new OrderedRange <double>(0.0, 1.0);
IMap <double, double> amplifier = new RangeMap(source, destination, Mappers.Linear);
if (stretchFactor < 1)
{
return(Krach.Graphics.Color.InterpolateRgb(Colors.Blue, baseColor, Scalars.InterpolateLinear, amplifier.Map((1.0 * stretchFactor).Clamp(source))));
}
if (stretchFactor > 1)
{
return(Krach.Graphics.Color.InterpolateRgb(Colors.Red, baseColor, Scalars.InterpolateLinear, amplifier.Map((1.0 / stretchFactor).Clamp(source))));
}
return(baseColor);
}
public static OrderedRange <double> Inflate(this OrderedRange <double> range, double value)
{
return(new OrderedRange <double>(range.Start - value, range.End + value));
}
public static double Length(this OrderedRange <double> range)
{
return(range.End - range.Start);
}
public static OrderedRange <int> Inflate(this OrderedRange <int> range, int value)
{
return(new OrderedRange <int>(range.Start - value, range.End + value));
}
public static int Length(this OrderedRange <int> range)
{
return(range.End - range.Start);
}
public RangeMap(OrderedRange <double> source, OrderedRange <double> destination, IFactory <IMap <double, double>, OrderedRange <double>, OrderedRange <double> > mapper)
: base(mapper.Create(source, destination))
{
this.source = source;
this.destination = destination;
}
public SymmetricRangeMap(OrderedRange <double> source, OrderedRange <double> destination, IFactory <IMap <double, double>, OrderedRange <double>, OrderedRange <double> > mapper)
: base(source, destination, GetFactory(mapper), GetFactory(mapper))
{
}
public static OrderedRange <double> Interpolate(OrderedRange <double> range1, OrderedRange <double> range2, Interpolation <double> interpolate, double fraction)
{
return(new OrderedRange <double>(interpolate(range1.Start, range2.Start, fraction), interpolate(range1.End, range2.End, fraction)));
}
public static IEnumerable <TSource> GetRange <TSource>(this IEnumerable <TSource> source, OrderedRange <int> range)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (range.Start < 0 || range.Start > source.Count())
{
throw new ArgumentOutOfRangeException("startIndex");
}
if (range.End < 0 || range.End > source.Count())
{
throw new ArgumentOutOfRangeException("endIndex");
}
return(source.Skip(range.Start).Take(range.Length()));
}
public SineMap(OrderedRange <double> source, OrderedRange <double> destination)
{
this.source = source;
this.destination = destination;
}
public static OrderedRange <TDestination> Map <TSource, TDestination>(this IMap <TSource, TDestination> map, OrderedRange <TSource> value)
where TSource : IEquatable <TSource>, IComparable <TSource>
where TDestination : IEquatable <TDestination>, IComparable <TDestination>
{
return(new OrderedRange <TDestination>(map.Map(value.Start), map.Map(value.End)));
}
public static T Clamp <T>(this T value, OrderedRange <T> range) where T : IEquatable <T>, IComparable <T>
{
return(value.Clamp(range.Start, range.End));
}
