public void Write(BinaryWriter writer)
{
writer.Write(Encoding.ASCII.GetBytes("ID3"));
writer.Write(majorVersion);
writer.Write(minorVersion);
writer.Write(BitField.FromBits(Enumerables.Create(unsynchronisation, extendedHeader, experimental, false, false, false, false, false)).Bytes.Single());
BitField dataLength = BitField.FromValue(DataLength, 28);
dataLength = BitField.FromBits
(
Enumerables.Concatenate
(
Enumerables.Create(false),
dataLength[0, 7].Bits,
Enumerables.Create(false),
dataLength[7, 14].Bits,
Enumerables.Create(false),
dataLength[14, 21].Bits,
Enumerables.Create(false),
dataLength[21, 28].Bits
)
);
writer.Write(dataLength.Bytes.ToArray());
foreach (ID3v2Frame frame in frames)
{
frame.Write(writer);
}
}
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()))
)
)
));
}
// polynomial
public static FunctionTerm Polynomial(int dimension, int degree)
{
if (dimension < 0)
{
throw new ArgumentOutOfRangeException("dimension");
}
if (degree < 0)
{
throw new ArgumentOutOfRangeException("degree");
}
Variable variable = new Variable(1, "x");
IEnumerable <Variable> coefficients =
(
from index in Enumerable.Range(0, degree)
select new Variable(dimension, string.Format("c{0}", index))
)
.ToArray();
return(Sum
(
from index in Enumerable.Range(0, degree)
let power = Exponentiation(variable, Constant(index))
let parameter = coefficients.ElementAt(index)
select Scaling(power, parameter)
)
.Abstract(Enumerables.Concatenate(Enumerables.Create(variable), coefficients)));
}
void RebuildSegmentComponents()
{
IEnumerable <PositionedControlComponent> orderedSpecificationComponents =
(
from specificationComponent in SpecificationComponents
orderby specificationComponent.Position ascending
select specificationComponent
)
.ToArray();
segmentComponents.Clear();
IEnumerable <PositionedControlComponent> segmentDelimitingComponents = Enumerables.Concatenate
(
Enumerables.Create(curveStartComponent),
orderedSpecificationComponents,
Enumerables.Create(curveEndComponent)
);
foreach (Tuple <PositionedControlComponent, PositionedControlComponent> segmentDelimitingComponentRange in segmentDelimitingComponents.GetRanges())
{
SegmentComponent segmentComponent = new SegmentComponent(this, this, segmentDelimitingComponentRange.Item1, segmentDelimitingComponentRange.Item2);
segmentComponent.InsertLength += InsertLength;
segmentComponent.SpecificationChanged += SpecificationChanged;
segmentComponent.AddSpecification += AddSpecification;
segmentComponent.SelectionChanged += SelectionChanged;
segmentComponents.Add(segmentComponent);
}
}
public static FunctionTerm Polynomial(IEnumerable <FunctionTerm> basis, int dimension)
{
if (basis == null)
{
throw new ArgumentNullException("basis");
}
if (dimension < 0)
{
throw new ArgumentOutOfRangeException("dimension");
}
ValueTerm variable = Variable("x");
IEnumerable <ValueTerm> coefficients =
(
from index in Enumerable.Range(0, basis.Count())
select Variable(string.Format("c_{0}", index), dimension)
)
.ToArray();
IEnumerable <ValueTerm> parameters = Enumerables.Concatenate(Enumerables.Create(variable), coefficients);
if (!basis.Any())
{
return(Constant(Enumerable.Repeat(0.0, dimension)).Abstract(parameters));
}
IEnumerable <ValueTerm> basisValues = basis.Select(basisFunction => basisFunction.Apply(variable));
return(Sum(Enumerable.Zip(basisValues, coefficients, Scaling)).Abstract(parameters));
}
public virtual void Write(BinaryWriter writer)
{
BitField header = BitField.FromBits
(
Enumerables.Concatenate
(
BitField.FromValue(0x07FF, 11).Bits,
BitField.FromValue((int)version, 2).Bits,
BitField.FromValue((int)layer, 2).Bits,
Enumerables.Create(!hasErrorProtection),
BitField.FromValue(bitRateID, 4).Bits,
BitField.FromValue(sampleRateID, 2).Bits,
Enumerables.Create(hasPadding),
Enumerables.Create(privateBit),
BitField.FromValue((int)channelMode, 2).Bits,
BitField.FromValue((int)joinID, 2).Bits,
Enumerables.Create(isCopyrighted),
Enumerables.Create(isOriginal),
BitField.FromValue((int)emphasis, 2).Bits
)
);
writer.Write(header.Bytes.ToArray());
if (hasErrorProtection)
{
writer.Write(checksum);
}
}
public IEnumerable <XElement> GetSvgPaths()
{
Kurve.Curves.Curve curve = optimizer.GetCurve(specification);
IEnumerable <string> curveCommands = Enumerables.Concatenate
(
Enumerables.Create(Svg.MoveTo(curve.GetPoint(0))),
from positions in Scalars.GetIntermediateValuesSymmetric(0, 1, SegmentCount + 1).GetRanges()
let controlPoint1 = curve.GetPoint(positions.Item1) + (1.0 / (3 * SegmentCount)) * curve.GetVelocity(positions.Item1)
let controlPoint2 = curve.GetPoint(positions.Item2) - (1.0 / (3 * SegmentCount)) * curve.GetVelocity(positions.Item2)
let point2 = curve.GetPoint(positions.Item2)
select Svg.CurveTo(controlPoint1, controlPoint2, point2)
);
yield return(Svg.PathShape(curveCommands, null, Colors.Black, 2));
IEnumerable <string> curvatureMarkersCommands =
(
from positions in Scalars.GetIntermediateValuesSymmetric(0, 1, SegmentCount + 1).GetRanges()
let position = Enumerables.Average(positions.Item1, positions.Item2)
let curvatureVector = CurvatureMarkersFactor * curve.GetCurvature(position) * curve.GetNormalVector(position)
select Svg.Line(curve.GetPoint(position), curve.GetPoint(position) + curvatureVector)
);
yield return(Svg.PathShape(curvatureMarkersCommands, null, Colors.Blue, 0.5));
foreach (PointCurveSpecification pointCurveSpecification in specification.BasicSpecification.CurveSpecifications.OfType <PointCurveSpecification>())
{
Vector2Double point = curve.GetPoint(pointCurveSpecification.Position);
yield return(Svg.CircleShape(point, 10, Colors.Red, null, 0));
}
foreach (DirectionCurveSpecification directionCurveSpecification in specification.BasicSpecification.CurveSpecifications.OfType <DirectionCurveSpecification>())
{
Vector2Double directionVector = curve.GetDirectionVector(directionCurveSpecification.Position);
Vector2Double start = curve.GetPoint(directionCurveSpecification.Position) - 1000 * directionVector;
Vector2Double end = curve.GetPoint(directionCurveSpecification.Position) + 1000 * directionVector;
yield return(Svg.LineShape(start, end, null, Colors.Green, 2));
}
foreach (CurvatureCurveSpecification curvatureCurveSpecification in specification.BasicSpecification.CurveSpecifications.OfType <CurvatureCurveSpecification>())
{
if (curvatureCurveSpecification.Curvature == 0)
{
Vector2Double directionVector = curve.GetDirectionVector(curvatureCurveSpecification.Position);
Vector2Double start = curve.GetPoint(curvatureCurveSpecification.Position) - 1000 * directionVector;
Vector2Double end = curve.GetPoint(curvatureCurveSpecification.Position) + 1000 * directionVector;
yield return(Svg.LineShape(start, end, null, Colors.Blue, 2));
}
else
{
Vector2Double center = curve.GetPoint(curvatureCurveSpecification.Position) - (1.0 / curvatureCurveSpecification.Curvature) * curve.GetNormalVector(curvatureCurveSpecification.Position);
double radius = 1.0 / curvatureCurveSpecification.Curvature.Absolute();
yield return(Svg.CircleShape(center, radius, null, Colors.Blue, 2));
}
}
}
public static IConstraint <ValueTerm> CreateEmpty()
{
return(new ExplicitConstraint <ValueTerm>
(
Term.Vector(),
Enumerables.Create <OrderedRange <double> >()
));
}
public virtual void Write(BinaryWriter writer)
{
writer.Write(Encoding.ASCII.GetBytes(identifier));
writer.Write(Binary.SwitchEndianness(DataLength));
writer.Write(BitField.FromBits(Enumerables.Create(!tagAlterPreservation, !fileAlterPreservation, readOnly, false, false, false, false, false)).Bytes.Single());
writer.Write(BitField.FromBits(Enumerables.Create(compression, encryption, groupingIdentity, false, false, false, false, false)).Bytes.Single());
}
public static IEnumerable <double> ToWaveletData(WaveletCollection waveletCollection)
{
return(Enumerables.Concatenate
(
Enumerables.Create(waveletCollection.smoothingCoefficient),
from level in waveletCollection.decomposition
from item in level
select item
)
.ToArray());
}
public override void MouseMove(Vector2Double mousePosition)
{
base.MouseMove(mousePosition);
if (IsDragging)
{
foreach (SpecificationComponent component in Enumerables.Create(leftComponent, rightComponent).OfType <SpecificationComponent>())
{
component.Point += DragVector * SlowDownFactor;
}
OnSpecificationChanged();
}
}
void AddCurve()
{
BasicSpecification basicSpecification = new BasicSpecification
(
100,
1,
new PolynomialFunctionTermCurveTemplate(10),
Enumerables.Create
(
new PointCurveSpecification(0.0, new Vector2Double(300, 300)),
new PointCurveSpecification(1.0, new Vector2Double(400, 300))
)
);
AddCurve(new CurveComponent(this, optimizationWorker, new Specification(basicSpecification)));
}
public override T Rewrite <T>(T term)
{
if (!(term is Application))
{
return(null);
}
Application application = (Application)(BaseTerm)term;
if (!(application.Function is Product))
{
return(null);
}
if (!(application.Parameter is Vector))
{
return(null);
}
Vector vector = (Vector)application.Parameter;
if (vector.Terms.Count() != 2)
{
return(null);
}
ValueTerm parameter0 = vector.Terms.ElementAt(0);
ValueTerm parameter1 = vector.Terms.ElementAt(1);
if (parameter0 is Application && ((Application)parameter0).Function is Product)
{
return(null);
}
if (!ShouldSwap(parameter0, parameter1))
{
return(null);
}
return((T)(BaseTerm) new Application(new Product(), new Vector(Enumerables.Create(parameter1, parameter0))));
}
public override FunctionTerm Substitute(Variable variable, ValueTerm substitute)
{
if (variables.Contains(variable))
{
return(this);
}
IEnumerable <Variable> newVariables = FindUnusedVariables
(
variables,
Enumerables.Concatenate
(
GetFreeVariables(),
Enumerables.Create(variable),
substitute.GetFreeVariables()
)
);
ValueTerm newTerm = term.Substitute(variables, newVariables);
return(new Abstraction(newVariables, newTerm.Substitute(variable, substitute)));
}
public override Syntax GetApplicationSyntax(Application application)
{
IEnumerable <ValueTerm> parameters = application.Parameter is Vector ? ((Vector)application.Parameter).Terms : Enumerables.Create(application.Parameter);
string parameter0Text = parameters.ElementAt(0).ToString();
string parameter1Text = parameters.ElementAt(1).ToString();
if (!parameter1Text.IsSubSuperScriptCompatible())
{
return(base.GetApplicationSyntax(application));
}
return(new BasicSyntax(string.Format("{0}{1}", parameter0Text, parameter1Text.ToSuperscript())));
}
void AddSpecification(double position)
{
SpecificationComponent pointSpecificationComponent = new SpecificationComponent(this, this, position, Enumerables.Create <CurveSpecification>());
AddSpecificationComponent(pointSpecificationComponent);
}
public BasicSpecification() : this(1, 1, new PolynomialFunctionTermCurveTemplate(2), Enumerables.Create <CurveSpecification>())
{
}
public override T Rewrite <T>(T term)
{
if (!(term is Application))
{
return(null);
}
Application application0 = (Application)(BaseTerm)term;
if (!(application0.Function is Product))
{
return(null);
}
if (!(application0.Parameter is Vector))
{
return(null);
}
Vector vector0 = (Vector)application0.Parameter;
if (vector0.Terms.Count() != 2)
{
return(null);
}
ValueTerm parameter00 = vector0.Terms.ElementAt(0);
ValueTerm parameter01 = vector0.Terms.ElementAt(1);
if (!(parameter00 is Application))
{
return(null);
}
Application application00 = (Application)parameter00;
if (!(application00.Function is Product))
{
return(null);
}
if (!(application00.Parameter is Vector))
{
return(null);
}
Vector vector00 = (Vector)application00.Parameter;
if (vector00.Terms.Count() != 2)
{
return(null);
}
ValueTerm parameter000 = vector00.Terms.ElementAt(0);
ValueTerm parameter001 = vector00.Terms.ElementAt(1);
// ((parameter000 . parameter001) . parameter01)
if (!ShouldSwap(parameter001, parameter01))
{
return(null);
}
return((T)(BaseTerm) new Application(new Product(), new Vector(Enumerables.Create(new Application(new Product(), new Vector(Enumerables.Create(parameter000, parameter01))), parameter001))));
}
static IEnumerable <Assignment> GetEquations(ValueTerm pattern, ValueTerm term)
{
if (pattern is BasicValueTerm)
{
if (!(term is BasicValueTerm))
{
return(null);
}
BasicValueTerm patternBasicValueTerm = (BasicValueTerm)pattern;
BasicValueTerm termBasicValueTerm = (BasicValueTerm)term;
if (patternBasicValueTerm != termBasicValueTerm)
{
return(null);
}
return(Enumerables.Create <Assignment>());
}
if (pattern is ValueDefinition)
{
if (!(term is ValueDefinition))
{
return(null);
}
ValueDefinition patternBasicValueTerm = (ValueDefinition)pattern;
ValueDefinition termBasicValueTerm = (ValueDefinition)term;
if (patternBasicValueTerm != termBasicValueTerm)
{
return(null);
}
return(Enumerables.Create <Assignment>());
}
if (pattern is Variable)
{
Variable patternVariable = (Variable)pattern;
return(Enumerables.Create(new Assignment(patternVariable, term)));
}
if (pattern is Application)
{
if (!(term is Application))
{
return(null);
}
Application patternApplication = (Application)pattern;
Application termApplication = (Application)term;
if (patternApplication.Function != termApplication.Function)
{
return(null);
}
return(GetEquations(patternApplication.Parameter, termApplication.Parameter));
}
if (pattern is Vector)
{
if (!(term is Vector))
{
return(null);
}
Vector patternVector = (Vector)pattern;
Vector termVector = (Vector)term;
if (patternVector.Terms.Count() != termVector.Terms.Count())
{
return(null);
}
List <Assignment> result = new List <Assignment>();
foreach (IEnumerable <Assignment> equations in Enumerable.Zip(patternVector.Terms, termVector.Terms, GetEquations))
{
if (equations == null)
{
return(null);
}
result.AddRange(equations);
}
return(result);
}
if (pattern is Selection)
{
if (!(term is Selection))
{
return(null);
}
Selection patternSelection = (Selection)pattern;
Selection termSelection = (Selection)term;
if (patternSelection.Index != termSelection.Index)
{
return(null);
}
return(GetEquations(patternSelection.Term, termSelection.Term));
}
throw new InvalidOperationException();
}
public static IEnumerable <FunctionTerm> GetDerivatives(this FunctionTerm term)
{
if (term is Sum)
{
Variable x = new Variable(1, "x");
Variable y = new Variable(1, "y");
return(Enumerables.Create
(
Term.Constant(1).Abstract(x, y),
Term.Constant(1).Abstract(x, y)
));
}
if (term is Product)
{
Variable x = new Variable(1, "x");
Variable y = new Variable(1, "y");
return(Enumerables.Create
(
y.Abstract(x, y),
x.Abstract(x, y)
));
}
if (term is Exponentiation)
{
Variable x = new Variable(1, "x");
Variable y = new Variable(1, "y");
return(Enumerables.Create
(
Term.Product(y, Term.Exponentiation(x, Term.Difference(y, Term.Constant(1)))).Abstract(x, y),
Term.Product(Term.Logarithm(x), Term.Exponentiation(x, y)).Abstract(x, y)
));
}
if (term is Logarithm)
{
Variable x = new Variable(1, "x");
return(Enumerables.Create(Term.Invert(x).Abstract(x)));
}
if (term is FunctionDefinition)
{
FunctionDefinition functionDefinitionTerm = (FunctionDefinition)term;
IEnumerable <FunctionTerm> derivatives = GetDerivatives(functionDefinitionTerm.Function).ToArray();
return
((
from index in Enumerable.Range(0, derivatives.Count())
let derivative = derivatives.ElementAt(index)
select new FunctionDefinition
(
string.Format("{0}_d{1}", functionDefinitionTerm.Name, index),
Rewriting.CompleteNormalization.Rewrite(derivative),
new BasicSyntax(string.Format("{0}'{1}", functionDefinitionTerm.Syntax.GetText(), index.ToString().ToSuperscript()))
)
)
.ToArray());
}
if (term is Abstraction)
{
Abstraction abstractionTerm = (Abstraction)term;
return
((
from variable in abstractionTerm.Variables
from derivative in GetDerivatives(abstractionTerm.Term, variable)
select derivative.Abstract(abstractionTerm.Variables)
)
.ToArray());
}
throw new InvalidOperationException();
}
public override T Rewrite <T>(T term)
{
if (!(term is Abstraction))
{
return(null);
}
Abstraction abstraction = (Abstraction)(BaseTerm)term;
if (!(abstraction.Term is Application))
{
return(null);
}
Application application = (Application)abstraction.Term;
IEnumerable <ValueTerm> parameters = application.Parameter is Vector ? ((Vector)application.Parameter).Terms : Enumerables.Create(application.Parameter);
if (!Enumerable.SequenceEqual(abstraction.Variables, parameters))
{
return(null);
}
return((T)(BaseTerm)application.Function);
}
public void SelectionChanged(PositionedControlComponent selectedComponent)
{
if (selectedComponent.IsSelected && !isShiftDown)
{
foreach (PositionedControlComponent component in PositionedControlComponents.Except(Enumerables.Create(selectedComponent)))
{
component.IsSelected = false;
}
Changed();
}
}
public override T Rewrite <T>(T term)
{
if (!(term is Vector))
{
return(null);
}
Vector vector = (Vector)(BaseTerm)term;
if (!vector.Terms.Any(subTerm => subTerm is Vector))
{
return(null);
}
return((T)(BaseTerm) new Vector
(
from subTerm in vector.Terms
let subSubTerms = subTerm is Vector ? ((Vector)subTerm).Terms : Enumerables.Create(subTerm)
from subSubTerm in subSubTerms
select subSubTerm
));
}
public override IEnumerable <double> Evaluate()
{
return(Enumerables.Create(value));
}
public override Syntax GetApplicationSyntax(Application application)
{
IEnumerable <ValueTerm> parameters = application.Parameter is Vector ? ((Vector)application.Parameter).Terms : Enumerables.Create(application.Parameter);
if (parameters.Count() != 2)
{
return(base.GetApplicationSyntax(application));
}
return(new BasicSyntax(string.Format("({0} {1} {2})", parameters.ElementAt(0), GetText(), parameters.ElementAt(1))));
}
