public void Validate(Programmer.Program program, string[] sources)
{
Log.WriteLine("Validating generated network...");
Options opts = Options.Instance;
double dt;
if (opts.DelayTimeStep <= 0)
{
dt = opts.ValidateRange[1];
}
else
{
dt = opts.DelayTimeStep;
}
double t = opts.ValidateRange[0];
var indices = d_monitors.ConvertAll <uint>(a => (uint)program.StateTable[a.Variable].DataIndex);
var dimensions = d_monitors.ConvertAll <Cdn.Dimension>(a => a.Variable.Dimension);
var dtstate = program.StateTable[Knowledge.Instance.TimeStep];
var len = d_data[0].Length - 1;
string shlib = opts.Formatter.CompileForValidation(sources, opts.Verbose);
IEnumerator <double[]> enu;
if (shlib != null)
{
enu = ValidateSharedLib(program, shlib, t, dt);
}
else
{
enu = ValidateProgram(program, sources, t, dt);
}
enu.MoveNext();
for (int i = 0; i < len; ++i)
{
var data = enu.Current;
ReadAndCompare(indices, dimensions, i, data, t);
enu.MoveNext();
t += data[dtstate.DataIndex];
}
Log.WriteLine("Network {0} successfully validated...", d_network.Filename);
}
private IEnumerator <double[]> ValidateSharedLib(Programmer.Program program, string shlib, double t, double dt)
{
// Create dynamic binding to the shared lib API for rawc
var dynnet = new DynamicNetwork(shlib, program.Options.Basename);
var dtstate = program.StateTable[Knowledge.Instance.TimeStep];
dynnet.Reset(t);
yield return(dynnet.Values());
while (true)
{
dynnet.Step(t, dt);
var vals = dynnet.Values();
yield return(vals);
t += vals[dtstate.DataIndex];
}
}
public string[] Write(Program program)
{
d_program = program;
Initialize(program, d_options);
string filename = Path.Combine(d_program.Options.Output, d_program.Options.Basename + ".js");
d_writer = new StreamWriter(filename);
d_writer.WriteLine("(function(Cdn) {");
WriteSource();
d_writer.WriteLine("})(typeof window !== 'undefined' ? (window.Cdn = window.Cdn || {}) : (global.Cdn = global.Cdn || {}))");
d_writer.Flush();
d_writer.Close();
return(new string[] { filename });
}
private IEnumerator <double[]> ValidateProgram(Programmer.Program program, string[] sources, double t, double dt)
{
return(Options.Instance.Formatter.RunForValidation(sources, t, dt));
}
public void Generate()
{
Profile.Do("load network", () => {
LoadNetwork();
});
if (Options.Instance.Validate)
{
d_validator = new Validator(d_network);
}
if (Options.Instance.DelayTimeStep > 0)
{
Cdn.Expression expr = new Cdn.Expression(Options.Instance.DelayTimeStep.ToString("R"));
Cdn.Instruction[] instr = new Cdn.Instruction[1];
instr[0] = new Cdn.InstructionNumber(Options.Instance.DelayTimeStep);
expr.Instructions = instr;
d_network.Integrator.AddVariable(new Cdn.Variable("delay_dt", expr, Cdn.VariableFlags.Out));
}
Profile.Do("initialize knowledge", () => {
// Initialize the knowledge
Knowledge.Initialize(d_network);
});
if (!Options.Instance.NoSparsity)
{
Profile.Do("sparsity", () => {
var sparsity = new Sparsity();
sparsity.Optimize();
});
}
var t = Profile.Begin("collect");
// Collect all the equations
Tree.Collectors.Result collection = Collect();
t.End();
t = Profile.Begin("filter");
// Filter conflicts and resolve final embeddings
Tree.Embedding[] embeddings = Filter(collection);
t.End();
t = Profile.Begin("resolve equations");
// Resolve final equations
Dictionary <State, Tree.Node> equations = ResolveEquations(embeddings);
t.End();
// Create program
t = Profile.Begin("create program");
Programmer.Program program = new Programmer.Program(ProgrammerOptions(), embeddings, equations);
t.End();
bool outistemp = false;
// Write program
if (Options.Instance.Validate || Options.Instance.Compile)
{
// Create a new temporary directory for the output files
string path = Path.GetTempFileName();
File.Delete(path);
Directory.CreateDirectory(path);
program.Options.Output = path;
outistemp = true;
}
else
{
Directory.CreateDirectory(program.Options.Output);
}
t = Profile.Begin("write program");
d_writtenFiles = Options.Instance.Formatter.Write(program);
t.End();
if (Options.Instance.PrintCompileSource)
{
foreach (string filename in d_writtenFiles)
{
Console.WriteLine("File: {0}", filename);
Console.WriteLine(File.ReadAllText(filename));
}
}
if (Options.Instance.Validate && !Options.Instance.PrintCompileSource)
{
try
{
d_validator.Validate(program, d_writtenFiles);
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
Directory.Delete(program.Options.Output, true);
Environment.Exit(1);
}
}
else if (Options.Instance.Compile)
{
var files = Options.Instance.Formatter.Compile(Options.Instance.Verbose);
if (Options.Instance.Verbose)
{
Log.WriteLine("Compiled {0}...", String.Join(", ", Array.ConvertAll <string, string>(files, a => Path.GetFileName(a))));
}
if (!String.IsNullOrEmpty(Options.Instance.Output))
{
try
{
Directory.CreateDirectory(Options.Instance.Output);
}
catch
{
}
}
foreach (var f in files)
{
var dest = Path.GetFileName(f);
if (!String.IsNullOrEmpty(Options.Instance.Output))
{
dest = Path.Combine(Options.Instance.Output, dest);
}
try
{
File.Delete(dest);
} catch {}
File.Move(f, dest);
}
}
if (outistemp)
{
try
{
Directory.Delete(program.Options.Output, true);
} catch {};
}
}
