public void SparseSample_ComplexFloat_Identity()
{
NumericsConfiguration.NativeProviderPath = @"C:\Program Files (x86)\Extreme Optimization\Numerical Libraries for .NET\bin\Net40";
NumericsConfiguration.Providers.RegisterSinglePrecisionProvider();
NumericsConfiguration.AutoLoadNativeProviders = true;
CoreImplementations <float> .UseNative();
Console.WriteLine(CoreImplementations <Complex <float> > .LinearAlgebra.Name);
SparseCompressedColumnMatrix <Complex <float> > matrixA = Matrix.CreateSparse <Complex <float> >(3, 3);
matrixA.SetValue(new Complex <float>(1, 0), 0, 0);
matrixA.SetValue(new Complex <float>(1, 0), 1, 1);
matrixA.SetValue(new Complex <float>(1, 0), 2, 2);
Vector <Complex <float> > vectorB = Vector.Create(new Complex <float>(1.0f, 0), new Complex <float>(2.0f, 0), new Complex <float>(3.0f, 0));
IterativeSparseSolver <Complex <float> > solver = new BiConjugateGradientSolver <Complex <float> >(matrixA);
DenseVector <Complex <float> > resultVector = solver.Solve(vectorB);
Console.WriteLine("Result: {0}", resultVector);
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.SolutionReport.Error);
// With incomplete LU preconditioner
solver.Preconditioner = new IncompleteLUPreconditioner <Complex <float> >(matrixA);
resultVector = solver.Solve(vectorB);
Console.WriteLine("Result: {0}", resultVector);
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.EstimatedError);
}
public APad ProcessClick(int logicalX, int logicalY)
{
if (LastCommand.IsOneOf(CommandType.Continue, CommandType.WaitClick))
{
return(From(Program, Exp.Call(Program, Memory.ToExp(), CoreImplementations.Pair(logicalX, logicalY))));
}
throw new InvalidOperationException(LastCommand.ToString());
}
public static Exp ToExp(this Data?data)
{
return(data switch
{
null => CoreImplementations.emptyList,
NumData n => n.Value,
PairData pair => CoreImplementations.Pair(pair.Value.ToExp(), pair.Next.ToExp()),
_ => throw new NotSupportedException($"{data}")
});
public void ExecuteSample()
{
// The line below sets the path where the native assemblies
// are located. The "XO_LIBRARY_PATH" environment variable
// points here, too.
NumericsConfiguration.NativeProviderPath =
@"C:\Program Files (x86)\Extreme Optimization\Numerical Libraries for .NET\bin\Net40";
// Register the single precision providers.
NumericsConfiguration.Providers.RegisterSinglePrecisionProvider();
NumericsConfiguration.AutoLoadNativeProviders = true;
CoreImplementations <float> .UseNative();
// Which provider are we using?
Console.WriteLine(CoreImplementations <Complex <float> > .LinearAlgebra.Name);
int N = 228724; // size
int K = 96; // non-zeros per column
// Create some random matrices. Code is below.
// Use a seed so we can reproduce the same values.
NumericsConfiguration.DefaultRandomNumberGenerator = new Extreme.Mathematics.Random.MersenneTwister(117);
var matrixA = CreateSparseRandom(N, K);
var vectorB = CreateRandom(N);// CreateRandom(N);
// Now run the solver with and without preconditioner:
var sw = Stopwatch.StartNew();
var solver = new BiConjugateGradientSolver <Complex <float> >(matrixA);
Console.WriteLine("Starting solve...");
Vector <Complex <float> > resultVector;
resultVector = solver.Solve(vectorB);
sw.Stop();
Console.WriteLine("Result: {0}", resultVector.GetSlice(0, 10));
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.SolutionReport.Error);
Console.WriteLine("Total time: {0} s", sw.Elapsed.TotalSeconds);
// With incomplete LU preconditioner
sw.Restart();
solver.Preconditioner = new IncompleteLUPreconditioner <Complex <float> >(matrixA);
resultVector = solver.Solve(vectorB);
sw.Stop();
Console.WriteLine("Result: {0}", resultVector.GetSlice(0, 10));
Console.WriteLine("Solved in {0} iterations.", solver.IterationsNeeded);
Console.WriteLine("Estimated error: {0}", solver.EstimatedError);
Console.WriteLine("Total time: {0} s", sw.Elapsed.TotalSeconds);
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
public static void RenderPages(string messageFilename, int scale, bool withWav, string outputDir)
{
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
var messageDir = Path.GetDirectoryName(messageFilename) !;
var message = File.ReadAllText(messageFilename);
var pages = message.Replace("\r", "").Split("\n\n");
for (int i = 0; i < pages.Length; i++)
{
var renderer = new RenderContext(Renderer.Instance);
var lines = pages[i].Split("\n");
var needBorder = false;
foreach (var line in lines)
{
try
{
if (line.StartsWith("//"))
{
continue;
}
if (line.StartsWith("IMAGE_"))
{
var imageName = line.Split("_", 2)[1];
using var stream = new FileStream(Path.Combine(messageDir, imageName), FileMode.Open);
var pixels = CoreImplementations.ImageToPixels(stream);
renderer.AddPixels(pixels);
}
else
{
ReportIncorrectMessagesToConsole(line);
needBorder = true;
renderer.AddLine(line);
}
}
catch (Exception e)
{
throw new Exception(line, e);
}
}
if (renderer.Points.Count == 0)
{
throw new Exception(i.ToString());
}
var humanReadableIndex = i + 1;
var points = needBorder ? AddBorder(renderer.Points.ToList()).ToList() : renderer.Points;
SaveImageFile(scale, points, Path.Combine(outputDir, $"message{humanReadableIndex}.png"));
if (withWav && i == 0)
{
SaveAudioFile(points, Path.Combine(outputDir, $"message{humanReadableIndex}.wav"));
}
}
}
public static APad Boot(Exp prog)
{
return(From(prog, Exp.Call(prog, CoreImplementations.emptyList, CoreImplementations.Pair(0, 0))));
}
private static Exp RegisterAndUseImage(string symbolName, CompilationContext context)
{
return(CoreImplementations.BitEncodeSymbolByName(symbolName));
}
public static Exp CompileExpression(ExpressionSyntax expression, CompilationContext context)
{
switch (expression)
{
case LiteralExpressionSyntax literal when literal.IsKind(SyntaxKind.StringLiteralExpression):
return(RegisterAndUseImage((string)literal.Token.Value !, context));
case LiteralExpressionSyntax literal when literal.IsKind(SyntaxKind.NumericLiteralExpression):
return(literal.Token.Value !is int?new Num((int)literal.Token.Value !) : new Num((long)literal.Token.Value !));
case LiteralExpressionSyntax literal when literal.IsKind(SyntaxKind.TrueLiteralExpression):
return(CoreImplementations.True);
case LiteralExpressionSyntax literal when literal.IsKind(SyntaxKind.FalseLiteralExpression):
return(CoreImplementations.False);
case LiteralExpressionSyntax literal when literal.IsKind(SyntaxKind.NullLiteralExpression):
return(CoreImplementations.emptyList);
case SimpleNameSyntax id:
return(GetFunction(id, context));
case BinaryExpressionSyntax bin when bin.IsKind(SyntaxKind.EqualsExpression) && bin.Right.IsKind(SyntaxKind.NullLiteralExpression):
return(CoreImplementations.isEmptyList.Call(CompileExpression(bin.Left, context)));
case BinaryExpressionSyntax bin when bin.IsKind(SyntaxKind.NotEqualsExpression) && bin.Right.IsKind(SyntaxKind.NullLiteralExpression):
return(CoreImplementations.not.Call(CoreImplementations.isEmptyList.Call(CompileExpression(bin.Left, context))));
case BinaryExpressionSyntax bin:
{
var left = CompileExpression(bin.Left, context);
var right = CompileExpression(bin.Right, context);
if (bin.IsKind(SyntaxKind.AddExpression))
{
return(left + right);
}
if (bin.IsKind(SyntaxKind.MultiplyExpression))
{
return(left * right);
}
if (bin.IsKind(SyntaxKind.SubtractExpression))
{
return(-right + left);
}
if (bin.IsKind(SyntaxKind.DivideExpression))
{
return(left / right);
}
if (bin.IsKind(SyntaxKind.ModuloExpression))
{
return(left % right);
}
if (bin.IsKind(SyntaxKind.LessThanExpression))
{
return(left < right);
}
if (bin.IsKind(SyntaxKind.GreaterThanExpression))
{
return(left > right);
}
if (bin.IsKind(SyntaxKind.LessThanOrEqualExpression))
{
return(left <= right);
}
if (bin.IsKind(SyntaxKind.GreaterThanOrEqualExpression))
{
return(left >= right);
}
if (bin.IsKind(SyntaxKind.EqualsExpression))
{
return(right == left);
}
if (bin.IsKind(SyntaxKind.NotEqualsExpression))
{
return(left != right);
}
if (bin.IsKind(SyntaxKind.LogicalAndExpression))
{
return(left & right);
}
if (bin.IsKind(SyntaxKind.LogicalOrExpression))
{
return(left | right);
}
break;
}
case PrefixUnaryExpressionSyntax prefixUnary:
{
var val = CompileExpression(prefixUnary.Operand, context);
if (prefixUnary.IsKind(SyntaxKind.UnaryMinusExpression))
{
return(CoreImplementations.negate.Call(val));
}
if (prefixUnary.IsKind(SyntaxKind.LogicalNotExpression))
{
return(CoreImplementations.not.Call(val));
}
break;
}
case ParenthesizedExpressionSyntax paren:
return(CompileExpression(paren.Expression, context));
case ConditionalExpressionSyntax cond:
return(CoreImplementations.If(
CompileExpression(cond.Condition, context),
CompileExpression(cond.WhenTrue, context),
CompileExpression(cond.WhenFalse, context)));
case InvocationExpressionSyntax inv:
{
var argsSyn = inv.ArgumentList.Arguments.Select(a => a.Expression).ToArray();
if (inv.Expression is MemberAccessExpressionSyntax memberAccess)
{
// call as method (smth.F(...))
var isExtensionMethod = !(context.SemanticModel.GetSymbolInfo(memberAccess.Expression).Symbol is ITypeSymbol);
var arguments = isExtensionMethod ? argsSyn.Prepend(memberAccess.Expression).ToArray() : argsSyn;
var funcName = memberAccess.Name.Identifier.Text;
var res = TryCompileSpecialFunctions(funcName, arguments, context);
if (!(res is null))
{
return(res);
}
// Call as static method Core.Pair(a, b)
var func = GetFunction(memberAccess, context);
return(CreateFunCall(func, arguments, context));
}
// Call as simple function f(x)
else if (inv.Expression is SimpleNameSyntax nameSyntax)
{
var res = TryCompileSpecialFunctions(nameSyntax.Identifier.Text, argsSyn, context);
if (!(res is null))
{
return(res);
}
}
return(CreateFunCall(CompileExpression(inv.Expression, context), argsSyn, context));
}
case SimpleLambdaExpressionSyntax simpleLambda:
{
var body =
simpleLambda.ExpressionBody != null
? CompileExpression(simpleLambda.ExpressionBody !, context)
: CompileBlock(simpleLambda.Block !.Statements, 0, context);
return(Exp.Lambda(simpleLambda.Parameter.Identifier.Text, body));
}
case ParenthesizedLambdaExpressionSyntax parenLambda:
{
var body =
parenLambda.ExpressionBody != null
? CompileExpression(parenLambda.ExpressionBody !, context)
: CompileBlock(parenLambda.Block !.Statements, 0, context);
var vars = parenLambda.ParameterList.Parameters.Select(p => p.Identifier.Text);
return(Exp.Lambda(vars, body));
}
case CastExpressionSyntax cast:
return(CompileExpression(cast.Expression, context));
case ImplicitArrayCreationExpressionSyntax impArray:
var values = impArray.Initializer.Expressions.Reverse().Select(expression1 => CompileExpression(expression1, context));
return(values.Aggregate(CoreImplementations.emptyList, (res, v) => new Pair(v, res)));
case ArrayCreationExpressionSyntax array:
return(array.Initializer !
.Expressions
.Reverse()
.Aggregate(
CoreImplementations.emptyList,
(res, v) => new Pair(CompileExpression(v, context), res)));
case MemberAccessExpressionSyntax memberAccess:
return(CompileMemberAccess(memberAccess, context));
case TupleExpressionSyntax tuple:
return(CoreImplementations.Tuple(tuple.Arguments.Select(a => CompileExpression(a.Expression, context)).ToArray()));
case ObjectCreationExpressionSyntax objCreation:
return(CoreImplementations.List(objCreation.ArgumentList !.Arguments.Select(a => CompileExpression(a.Expression, context)).ToArray()));
}
throw new NotSupportedException($"{expression}: {expression.GetType()} {expression.Kind()}");
}
