public GenerateSettingsWizard(IGenerator generator, List<Type> generatorTypeList)
: this()
{
//Only show this the first time if never generated
var cacheFile = new ModelCacheFile(generator);
if (cacheFile.FileExists())
{
this.DialogResult = DialogResult.Cancel;
this.IsValid = false;
return;
}
_generatorTypeList = generatorTypeList;
//Load all wizard files
var xmlFileList = Directory.GetFiles(AddinAppData.Instance.ExtensionDirectory, "genwizard.*.xml");
foreach (var fileName in xmlFileList)
{
this.LoadWizardFile(fileName);
}
if (cboItem.Items.Count == 0)
{
this.DialogResult = DialogResult.Cancel;
this.IsValid = false;
return;
}
cboItem.SelectedIndex = 0;
}
public Import(ILocalhost localhost, IGenerator generator)
{
this.localhost = localhost;
this.generator = generator;
mapper = new Mapper<Key, Key>();
interactions = new List<Interaction>();
}
/// <summary>
/// Initializes a new instance of a Generator.
/// </summary>
/// <param name="generator">The text generator to wrap.</param>
internal Generator(IGenerator generator)
{
_generator = generator;
_foundHandlers = new List<EventHandler<KeyFoundEventArgs>>();
_notFoundHandlers = new List<EventHandler<KeyNotFoundEventArgs>>();
_valueRequestedHandlers = new List<EventHandler<ValueRequestEventArgs>>();
}
private static void GenerateWithWatch(IGenerator g)
{
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\r\n{0}: ", g);
Console.ResetColor();
Console.Write("Working...\r\n");
List<string> result = null;
var sw = new Stopwatch();
var total = 0L;
for (int i = 0;i < _loop;i++)
{
sw.Reset();
sw.Start();
result = g.Generate(DIC, _len);
sw.Stop();
total += sw.ElapsedMilliseconds;
if (i <= 10)
{
Console.WriteLine("\tGot {0} items in {1,7}ms", result.Count, sw.ElapsedMilliseconds);
if (i == 10 && _loop > 10)
{
Console.WriteLine("\t......");
}
}
}
Console.WriteLine("\tGenerate finished for {2} times in {0,7}ms, {1,7}ms for each time.", total, total / _loop, _loop);
if (result != null)
{
PrintTheResult(result);
}
}
private void btnScramble_Click(object sender, RoutedEventArgs e)
{
Generator = new Shuffle(Math.Sqrt(3) / 3, 6, 18, Convert.ToInt32(tb_amounttests.Text));
var frequencies = Generator.FrequenciesTest();
lb_Scramble.ItemsSource = frequencies;
tb_scrhi.Text = Generator.CriterionX(frequencies).ToString();
}
public void Setup()
{
ccu = new CodeCompileUnit();
mocks = new MockRepository();
engine = Engine.GlobalEngine;
engine.BinPath = @"C:\Program Files (x86)\MSBuild";
project = new Project();
buildEngine = mocks.DynamicMock<MockBuildEngine>(project);
logger = new NullLogger();
parserService = mocks.DynamicMock<ISiteTreeGeneratorService>();
naming = mocks.DynamicMock<INamingService>();
sourceStorage = mocks.DynamicMock<IParsedSourceStorageService>();
source = mocks.DynamicMock<ISourceGenerator>();
typeResolver = mocks.DynamicMock<ITypeResolver>();
treeService = mocks.DynamicMock<ITreeCreationService>();
viewSourceMapper = mocks.DynamicMock<IViewSourceMapper>();
generator = mocks.DynamicMock<IGenerator>();
task = new GenerateMonoRailSiteTreeTask(logger, parserService, naming, source, sourceStorage, typeResolver,
treeService, viewSourceMapper, generator);
item = mocks.DynamicMock<ITaskItem>();
parsedSource = mocks.DynamicMock<IParser>();
}
public Field(IGenerator generator)
{
_generator = generator;
_generator.Generate(this);
if (_tiles == null || _types == null)
throw new Exception("Generator failed. Tiles or TileTypes missing!");
}
public DiscoTask(Settings settings, IGenerator<amBXScene> randomSceneGenerator, NotificationClientBase notificationService, Random random)
{
this.settings = settings;
this.randomSceneGenerator = randomSceneGenerator;
this.notificationService = notificationService;
this.random = random;
}
public Toolchain(string name, IGenerator generator, IBuilder builder, IExecutor executor)
{
Name = name;
Generator = generator;
Builder = builder;
Executor = executor;
}
public HelloWorldController(IGenerator generator)
{
if (generator == null)
throw new ArgumentNullException("generator");
_Generator = generator;
}
public void PerformSampling(string name, IGenerator layer)
{
PerformSamplingIndividual(name, layer, 5, 0);
PerformSamplingIndividual(name, layer, 5, 100);
PerformSamplingIndividual(name, layer, 5, 10000);
PerformSamplingIndividual(name, layer, 5, 10000000);
}
public VertexSourceAdapter(IVertexSource vertexSource, IGenerator generator)
{
markers = new null_markers();
this.VertexSource = vertexSource;
this.generator = generator;
m_status = status.initial;
}
/// <summary>
/// Trains a single model based on a generator
/// a predefined number of times with the provided
/// examples and data split and selects the best
/// (or most accurate) model
/// </summary>
/// <param name="examples">Source data</param>
/// <param name="trainingPercentage">Data split percentage</param>
/// <param name="repeat">Number of repetitions per generator</param>
/// <param name="generator">Model generator used</param>
/// <returns>Best model for provided generator</returns>
public static LearningModel Learn(IEnumerable<object> examples, double trainingPercentage, int repeat, IGenerator generator)
{
var total = examples.Count();
var descriptor = generator.Descriptor;
var data = descriptor.Convert(examples).ToExamples();
Matrix x = data.Item1;
Vector y = data.Item2;
var models = new IModel[repeat];
var accuracy = Vector.Zeros(repeat);
// run in parallel since they all have
// read-only references to the data model
// and update indices independently
Parallel.For(0, models.Length, i =>
{
var t = GenerateModel(generator, x, y, examples, trainingPercentage);
models[i] = t.Model;
accuracy[i] = t.Accuracy;
});
var idx = accuracy.MaxIndex();
return new LearningModel { Generator = generator, Model = models[idx], Accuracy = accuracy[idx] };
}
public static void Main(string[] args)
{
var targetDirectory = Path.GetFullPath(args.Length > 0 ? args[0] : ".");
var outputDirectory = Path.GetFullPath(args.Length > 1 ? args[1] : ".");
var options = args.Length > 2 ? args[2] : "";
if (!Directory.Exists(targetDirectory))
return;
if (!Directory.Exists(outputDirectory))
MiscUtil.CreateDirectory(outputDirectory);
var generators = new IGenerator[]
{
new MessageCodeGenerator(outputDirectory, options),
new DataCodeGenerator(outputDirectory),
new AttributeCodeGenerator(outputDirectory)
};
var targetFiles = Directory.GetFiles(targetDirectory, "*.xml", SearchOption.AllDirectories);
Parallel.ForEach(targetFiles, eachFile =>
{
var document = new XmlDocument();
document.Load(eachFile);
Parallel.ForEach(generators, e => e.Load(eachFile, document));
});
Parallel.ForEach(generators, e => e.Generate());
}
///<summary>
///</summary>
///<param name="source"></param>
///<param name="generator"></param>
public ConverterAdaptorVcgen(IVertexSource source, IGenerator generator)
{
_markers = new NullMarkers();
_source = source;
_generator = generator;
_status = EStatus.Initial;
}
private void BuildBuffers(IGenerator generator)
{
List<MyOwnVertexFormat> vertices = new List<MyOwnVertexFormat>();
for (int x = 0; x < sideSize; x++)
{
for (int z = 0; z < sideSize; z++)
{
for (int y = 0; y < sideSize; y++)
{
double sample = generator.Sample(new Vector3(x, y, z) + location);
if ( sample > 0.6f)
{
CreateVertices(vertices, x, y, z, new Color((float)sample, (float)sample, (float)sample));
}
}
}
}
if(vertices.Count > 0)
{
vertexBuffer = new VertexBuffer(device, MyOwnVertexFormat.VertexDeclaration, vertices.Count, BufferUsage.WriteOnly);
vertexBuffer.SetData(vertices.ToArray());
}
numVertices = vertices.Count;
}
public void Emit(IGenerator codeEmittor)
{
foreach(var i in _instructions)
{
i.Emit(codeEmittor);
}
}
private static void ProcessTree(Option<IAbstractSyntaxTree> ast, IGenerator generator)
{
if (!ast.Any())
return;
generator.Process(ast.Single());
}
private void btnAnalytic_Click(object sender, RoutedEventArgs e)
{
Generator = new Analytic(18, 17, 8, 1, Convert.ToInt32(tb_amounttests.Text));
var frequencies = Generator.FrequenciesTest();
lB_Analytic.ItemsSource = frequencies;
tb_anhi.Text = Generator.CriterionX(frequencies).ToString();
}
public void AddFile(string fullPath, IGenerator generator)
{
var path = System.IO.Path.Combine(Environment.CurrentDirectory, fullPath);
var item = new GeneratedItem(path, x => File.WriteAllText(path, generator.GetText()), File.Exists);
Items.Add(item);
}
public MD5CollisionCalculator()
{
_generator = new Generator();
_workerPool = new List<IWorker>();
_nrOfWorkerTasks = 0;
_passCount = 0;
_running = false;
}
public MaintenanceService(Infrastructure infrastructure, FhirService service)
{
this.service = service;
this.localhost = infrastructure.Localhost;
this.generator = infrastructure.Generator;
this.store = infrastructure.Store;
this.index = infrastructure.Index;
}
public GeneratingLeafNode(GraphicsDevice device, IGenerator generator, Vector3 pos, int size)
{
this.device = device;
location = pos;
sideSize = size;
boundingBoxes = new List<BoundingBox>();
BuildBuffers(generator);
}
public ConvAdaptorVcgen(IVertexSource source, IGenerator generator)
{
this.markers = null;
// TODO NullMarkers();
this.source = source;
this.generator = generator;
this.status = Status.Initial;
}
public MaintenanceService(FhirService fhirService, ILocalhost localhost, IGenerator keyGenerator, IFhirStore fhirStore, IFhirIndex fhirIndex)
{
this.fhirService = fhirService;
this.localhost = localhost;
this.keyGenerator = keyGenerator;
this.fhirStore = fhirStore;
this.fhirIndex = fhirIndex;
}
public ChunkCache(IGenerator Source)
{
_chunks = new Chunk[NUM_CHUNKS][];
for (int i = 0; i< _chunks.Length; ++i) {
_chunks [i] = new Chunk[NUM_CHUNKS];
}
_gen = Source;
}
public void Display(IGenerator generator)
{
textBox1.Text = string.Empty;
foreach (object o in generator.Get())
{
textBox1.Text += o + Environment.NewLine;
}
}
private void darkListBox1_SelectedIndexChanged(object sender, EventArgs e)
{
currentGenerator = darkListBox1.SelectedItem as IGenerator;
if (currentGenerator != null)
{
UpdateControls();
}
}
public void Register(Type type, IGenerator generator)
{
if(_generators.Has(type))
{
_generators.Remove(type);
}
_generators.Fill(type, generator);
}
public ModelCacheFile(IGenerator root)
: this()
{
if (root == null)
throw new Exception("The root element cannot be null");
_modelFileName = root.FileName;
this.Load();
}
public void ReplaceGenerator <T> (IGenerator <T> generator)
{
generators[typeof(T)] = generator;
generators[typeof(Nullable <>).MakeGenericType(typeof(T))] = new NullableGenerator <T>(generator);
}
/// <summary>
/// Generates source code for the specified test case, assembles it, and compares
/// the output of both steps to expected values. The process is repeated for every
/// known assembler.
///
/// If an assembler is known but not configured, the assembly step is skipped, and
/// does not count as a failure.
/// </summary>
/// <param name="pathName">Full path to test case.</param>
/// <returns>True if all assemblers worked as expected.</returns>
private bool GenerateAndAssemble(string pathName)
{
ReportProgress(Path.GetFileName(pathName) + "...\r\n");
// Create DisasmProject object, either as a new project for a plain data file,
// or from a project file.
DisasmProject project = InstantiateProject(pathName,
out FileLoadReport projectLoadReport);
if (project == null)
{
ReportFailure();
return(false);
}
int testNum = GetTestNum(pathName);
// Create a temporary directory to work in.
string workDir = CreateWorkDirectory(pathName);
if (string.IsNullOrEmpty(workDir))
{
ReportFailure();
project.Cleanup();
return(false);
}
AppSettings settings = CreateNormalizedSettings();
ApplyProjectSettings(settings, project);
// Iterate through all known assemblers.
bool didFail = false;
foreach (AssemblerInfo.Id asmId in
(AssemblerInfo.Id[])Enum.GetValues(typeof(AssemblerInfo.Id)))
{
if (asmId == AssemblerInfo.Id.Unknown)
{
continue;
}
string fileName = Path.GetFileName(pathName);
TaskTimer timer = new TaskTimer();
timer.StartTask("Full Test Duration");
// Create results object and add it to the list. We'll add stuff to it for
// as far as we get.
GenTestResults results = new GenTestResults(pathName, asmId);
mResults.Add(results);
results.ProjectLoadReport = projectLoadReport;
// Generate source code.
ReportProgress(" " + asmId.ToString() + " generate...");
IGenerator gen = AssemblerInfo.GetGenerator(asmId);
if (gen == null)
{
ReportErrMsg("generator unavailable");
ReportProgress("\r\n");
//didFail = true;
continue;
}
timer.StartTask("Generate Source");
gen.Configure(project, workDir, fileName,
AssemblerVersionCache.GetVersion(asmId), settings);
List <string> genPathNames = gen.GenerateSource(mWorker);
timer.EndTask("Generate Source");
if (mWorker.CancellationPending)
{
// The generator will stop early if a cancellation is requested. If we
// don't break here, the compare function will report a failure, which
// isn't too problematic but looks funny.
break;
}
ReportProgress(" verify...");
timer.StartTask("Compare Source to Expected");
bool match = CompareGeneratedToExpected(pathName, genPathNames);
timer.EndTask("Compare Source to Expected");
if (match)
{
ReportSuccess();
results.GenerateOkay = true;
}
else
{
ReportFailure();
didFail = true;
// The fact that it doesn't match the expected sources doesn't mean it's
// invalid. Go ahead and try to build it.
//continue;
}
// Assemble code.
ReportProgress(" " + asmId.ToString() + " assemble...");
IAssembler asm = AssemblerInfo.GetAssembler(asmId);
if (asm == null)
{
ReportErrMsg("assembler unavailable");
ReportProgress("\r\n");
continue;
}
timer.StartTask("Assemble Source");
asm.Configure(genPathNames, workDir);
AssemblerResults asmResults = asm.RunAssembler(mWorker);
timer.EndTask("Assemble Source");
if (asmResults == null)
{
ReportErrMsg("unable to run assembler");
ReportFailure();
didFail = true;
continue;
}
if (asmResults.ExitCode != 0)
{
ReportErrMsg("assembler returned code=" + asmResults.ExitCode);
ReportFailure();
didFail = true;
continue;
}
results.AsmResults = asmResults;
ReportProgress(" verify...");
timer.StartTask("Compare Binary to Expected");
FileInfo fi = new FileInfo(asmResults.OutputPathName);
if (fi.Length != project.FileData.Length)
{
ReportErrMsg("asm output mismatch: length is " + fi.Length + ", expected " +
project.FileData.Length);
ReportFailure();
didFail = true;
continue;
}
else if (!FileUtil.CompareBinaryFile(project.FileData, asmResults.OutputPathName,
out int badOffset, out byte badFileVal))
{
ReportErrMsg("asm output mismatch: offset +" + badOffset.ToString("x6") +
" has value $" + badFileVal.ToString("x2") + ", expected $" +
project.FileData[badOffset].ToString("x2"));
ReportFailure();
didFail = true;
continue;
}
timer.EndTask("Compare Binary to Expected");
// Victory!
results.AssembleOkay = true;
ReportSuccess();
timer.EndTask("Full Test Duration");
results.Timer = timer;
// We don't scrub the directory on success at this point. We could, but we'd
// need to remove only those files associated with the currently assembler.
// Otherwise, a failure followed by a success would wipe out the unsuccessful
// temporaries.
}
// If something failed, leave the bits around for examination. Otherwise, try to
// remove the directory and all its contents.
if (!didFail && !RetainOutput)
{
ScrubWorkDirectory(workDir, testNum);
RemoveWorkDirectory(workDir);
}
project.Cleanup();
return(!didFail);
}
protected override CauchyDistribution GetDistWithParams(IGenerator gen, CauchyDistribution other = null)
{
return(new CauchyDistribution(gen, GetAlpha(other), GetGamma(other)));
}
/// <summary>
/// Constructs a new TransformGenerator that generates elements from the given generator, transformed
/// by the given transform.
/// </summary>
/// <param Name="generator">The generator to use for generating elements</param>
/// <param Name="transform">The transform to apply to generated elements before they are returned.</param>
public TransformGenerator(IGenerator <U> generator, Func <U, T> transform)
{
this.generator = generator;
this.transform = transform;
}
public static IGenerator <T> Select <T, U>(this IGenerator <U> generator, Func <U, T> transform)
{
return(new TransformGenerator <T, U>(generator, transform));
}
public static IGenerator <T> Where <T>(this IGenerator <T> generator, Func <T, bool> predicate)
{
return(new FilterGenerator <T>(generator, predicate));
}
static void Main(string[] args)
{
var generators = new IGenerator[]
{
new ProjectsGenerator(),
new ProtoGenerator(),
new MessageGenerator()
};
List <CybtansConfig> configs = null;
if (args == null || args.Length == 0)
{
Console.WriteLine("Generate code from config files: cybtans-cli [base path]");
Console.WriteLine("Other options:");
foreach (var item in generators)
{
Console.WriteLine();
item.PrintHelp();
}
return;
}
else if (args.Length == 1)
{
configs = CybtansConfig.SearchConfigs(args[0]).ToList();
if (configs.Count == 0)
{
Console.WriteLine("No \"cybtans.json\" config files were found");
return;
}
}
try
{
if (configs != null && configs.Any())
{
foreach (var config in configs)
{
foreach (var step in config.Steps)
{
foreach (var item in generators)
{
if (item.Generate(config, step))
{
break;
}
}
}
}
return;
}
foreach (var item in generators)
{
if (item.CanGenerate(args[0]) && item.Generate(args))
{
return;
}
}
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
var ex = e;
while (ex != null)
{
Console.WriteLine(ex.Message);
ex = ex.InnerException;
}
Console.ResetColor();
}
}
protected internal static Expression GetAst(object args, CodeBlock cb, bool istailposition)
{
var spanHint = SpanHint;
if (args is Annotation)
{
args = ((Annotation)args).stripped;
}
Cons c = args as Cons;
if (c != null)
{
// in debug mode, this will be (annotated-call <location> . symbol)
// TODO: see if the discarded annotation is useful
if (ScriptDomainManager.Options.DebugMode && c.car is Cons)
{
Cons ac = c.car as Cons;
if (ac.car == SymbolTable.StringToObject("annotated-call"))
{
object se = ((Cons)ac.cdr).cdr;
if (se is SymbolId)
{
c.car = se;
}
}
}
if (c.car is SymbolId)
{
SymbolId f = (SymbolId)c.car;
Variable var = cb.Lookup(f);
if (var != null && !assigns.ContainsKey(f))
{
var = null;
}
object m;
#if OPTIMIZATIONS
#if !BLAH
CodeBlockExpression cbe;
//// needs to do the same for overloads...
if (SimpleGenerator.libraryglobals.TryGetValue(f, out cbe))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (cbe.Block.ParameterCount < 9 && cbe.Block.ParameterCount == ppp.Length)
{
//inline here? we could for simple bodies, but we need to copy the entire structure
if (!(cbe.Block.HasEnvironment || cbe.Block.IsClosure))
{
if (cbe.Block.Body is ReturnStatement)
{
ReturnStatement rs = (ReturnStatement)cbe.Block.Body;
if (!cb.IsGlobal && IsSimpleExpression(rs.Expression))
{
return(InlineCall(cb, Ast.CodeBlockExpression(RewriteBody(cbe.Block), false, cbe.IsStronglyTyped), ppp));
}
}
}
if (cbe.Block != cb.Parent && cbe.Block != cb) // do TCE later
{
return(CallNormal(cbe, ppp));
}
}
}
// varargs
if (SimpleGenerator.libraryglobalsX.TryGetValue(f, out cbe))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (cbe.Block.ParameterCount < 9 && cbe.Block.ParameterCount - 1 <= ppp.Length)
{
//inline here?
return(CallVarArgs(cbe, ppp));
}
}
// overloads
CodeBlockDescriptor[] cbd;
if (SimpleGenerator.libraryglobalsN.TryGetValue(f, out cbd))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
foreach (CodeBlockDescriptor d in cbd)
{
if (d.codeblock.Block.ParameterCount < 9)
{
if (ppp.Length == d.arity || (d.varargs && ppp.Length > d.arity))
{
if (d.varargs)
{
//inline here?
return(CallVarArgs(d.codeblock, ppp));
}
else
{
//inline here?
//if (d.codeblock.Block != cb.Parent && d.codeblock.Block != cb) // do TCE later, not yet
{
return(CallNormal(d.codeblock, ppp));
}
}
}
}
}
}
#endif
//if (!ScriptDomainManager.Options.DebugMode)
{
if (f == SymbolTable.StringToId("call-with-values"))
{
Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (ppp.Length == 2 && ppp[1] is MethodCallExpression)
{
MethodCallExpression consumer = ppp[1] as MethodCallExpression;
if (ppp[0] is MethodCallExpression)
{
MethodCallExpression producer = ppp[0] as MethodCallExpression;
if (consumer.Method == Closure_Make && producer.Method == Closure_Make)
{
CodeBlockExpression ccbe = consumer.Arguments[0] as CodeBlockExpression;
CodeBlockExpression pcbe = producer.Arguments[0] as CodeBlockExpression;
pcbe.Block.Bind();
ccbe.Block.Bind();
if (ccbe.Block.ParameterCount == 0)
{
return(InlineCall(cb, ccbe));
}
else if (ccbe.Block.ParameterCount == 1)
{
return(InlineCall(cb, ccbe, Ast.SimpleCallHelper(typeof(Helpers).GetMethod("UnwrapValue"), InlineCall(cb, pcbe))));
}
else
{
Variable values = cb.CreateTemporaryVariable((SymbolId)Builtins.GenSym("values"), typeof(object[]));
Expression valuesarr = Ast.Read(values);
Expression[] pppp = new Expression[ccbe.Block.ParameterCount];
for (int i = 0; i < pppp.Length; i++)
{
pppp[i] = Ast.ArrayIndex(valuesarr, Ast.Constant(i));
}
return(Ast.Comma(
Ast.Void(
Ast.Write(
values,
Ast.ComplexCallHelper(
Ast.SimpleCallHelper(typeof(Helpers).GetMethod("WrapValue"), InlineCall(cb, pcbe)),
typeof(MultipleValues).GetMethod("ToArray", new Type[] { typeof(int) }),
Ast.Constant(pppp.Length)))),
InlineCall(cb, ccbe, pppp)));
}
}
}
if (consumer.Method == Closure_Make)
{
CodeBlockExpression ccbe = consumer.Arguments[0] as CodeBlockExpression;
ccbe.Block.Bind();
Expression producer = ppp[0];
Expression exx = Ast.ConvertHelper(producer, typeof(Callable));
MethodInfo callx = GetCallable(0);
if (ccbe.Block.ParameterCount == 0)
{
return(InlineCall(cb, ccbe));
}
else if (ccbe.Block.ParameterCount == 1)
{
return(InlineCall(cb, ccbe, Ast.SimpleCallHelper(typeof(Helpers).GetMethod("UnwrapValue"), Ast.Call(exx, callx))));
}
else
{
Variable values = cb.CreateTemporaryVariable((SymbolId)Builtins.GenSym("values"), typeof(object[]));
Expression valuesarr = Ast.Read(values);
Expression[] pppp = new Expression[ccbe.Block.ParameterCount];
for (int i = 0; i < pppp.Length; i++)
{
pppp[i] = Ast.ArrayIndex(valuesarr, Ast.Constant(i));
}
return(Ast.Comma(
Ast.Void(
Ast.Write(
values,
Ast.ComplexCallHelper(
Ast.SimpleCallHelper(typeof(Helpers).GetMethod("WrapValue"),
Ast.Call(exx, callx)),
typeof(MultipleValues).GetMethod("ToArray", new Type[] { typeof(int) }),
Ast.Constant(pppp.Length)))),
InlineCall(cb, ccbe, pppp)));
}
}
}
else
{
;
}
}
}
#endif
// this can be enabled once builtins are auto CPS'd.
// ok I tried, but there are issues still, not sure what
#if OPTIMIZATIONS
// check for inline emitter
InlineEmitter ie;
if (TryGetInlineEmitter(f, out ie))
{
Expression result = ie(GetAstList(c.cdr as Cons, cb));
// if null is returned, the method cannot be inlined
if (result != null)
{
if (spanHint.IsValid)
{
result.SetLoc(spanHint);
}
return(result);
}
}
#endif
if (Context.Scope.TryLookupName(f, out m))
{
if (var == null)
{
IGenerator gh = m as IGenerator;
if (gh != null)
{
return(gh.Generate(c.cdr, cb));
}
BuiltinMethod bf = m as BuiltinMethod;
if (bf != null)
{
MethodBinder mb = bf.Binder;
Expression[] pars = Array.ConvertAll(GetAstList(c.cdr as Cons, cb), e => Unwrap(e));
if (bf.AllowConstantFold && !Debugger.IsAttached)
{
bool constant = Array.TrueForAll(pars, e => e is ConstantExpression && e.Type != typeof(BigInteger));
if (constant)
{
object[] cargs = Array.ConvertAll(pars, e => GetRuntimeConstant((ConstantExpression)e));
CallTarget0 disp = delegate
{
return(bf.Call(cargs));
};
CallTarget1 handler = delegate(object e)
{
throw new CompileTimeEvaluationException();
};
try
{
object result = Runtime.R6RS.Exceptions.WithExceptionHandler(
Closure.Create(handler),
Closure.Create(disp));
var rrrr = GetCons(result, cb);
if (spanHint.IsValid)
{
rrrr.SetLoc(spanHint);
}
return(rrrr);
}
catch (CompileTimeEvaluationException)
{
}
}
}
Type[] types = GetExpressionTypes(pars);
MethodCandidate mc = mb.MakeBindingTarget(CallType.None, types);
if (mc != null)
{
if (mc.Target.NeedsContext)
{
pars = ArrayUtils.Insert <Expression>(Ast.CodeContext(), pars);
}
MethodBase meth = mc.Target.Method;
var rrrr = Ast.ComplexCallHelper(meth as MethodInfo, pars);
if (spanHint.IsValid)
{
rrrr.SetLoc(spanHint);
}
return(rrrr);
}
}
Closure clos = m as Closure;
if (clos != null && !SetGenerator.IsAssigned(f))
{
// no provision for varargs
MethodInfo[] mis = clos.Targets;
if (mis.Length > 0)
{
MethodBinder mb = MethodBinder.MakeBinder(binder, SymbolTable.IdToString(f), mis, BinderType.Normal);
Expression[] pars = Array.ConvertAll(GetAstList(c.cdr as Cons, cb), e => Unwrap(e));
if (clos.AllowConstantFold && !Debugger.IsAttached)
{
bool constant = Array.TrueForAll(pars, e => e is ConstantExpression && e.Type != typeof(BigInteger));
if (constant)
{
object[] cargs = Array.ConvertAll(pars, e => GetRuntimeConstant((ConstantExpression)e));
CallTarget0 disp = delegate
{
var rrrr = clos.Call(cargs);
return(rrrr);
};
CallTarget1 handler = delegate(object e)
{
throw new CompileTimeEvaluationException();
};
try
{
object result = Runtime.R6RS.Exceptions.WithExceptionHandler(
Closure.Create(handler),
Closure.Create(disp));
var rrrr = GetCons(result, cb);
if (spanHint.IsValid)
{
rrrr.SetLoc(spanHint);
}
return(rrrr);
}
catch (CompileTimeEvaluationException)
{
}
}
}
// exclude transient members if needed
if (!AllowTransientBinding)
{
mis = Array.FindAll(mis, x => !IsTransient(x.Module));
}
if (mis.Length > 0)
{
Type[] types = GetExpressionTypes(pars);
MethodCandidate mc = mb.MakeBindingTarget(CallType.None, types);
if (mc != null)
{
if (mc.Target.NeedsContext)
{
pars = ArrayUtils.Insert <Expression>(Ast.CodeContext(), pars);
}
MethodBase meth = mc.Target.Method;
var rrrr = Ast.ComplexCallHelper(meth as MethodInfo, pars);
if (spanHint.IsValid)
{
rrrr.SetLoc(spanHint);
}
return(rrrr);
}
}
}
// check for overload thing
}
}
}
}
Expression ex = Unwrap(GetAst(c.car, cb));
// a 'let'
if (ex is MethodCallExpression)
{
var ppp = GetAstList(c.cdr as Cons, cb);
MethodCallExpression mcexpr = (MethodCallExpression)ex;
if (mcexpr.Method == Closure_Make)
{
CodeBlockExpression cbe = mcexpr.Arguments[0] as CodeBlockExpression;
if (ppp.Length < 9 && cbe.Block.ParameterCount == ppp.Length)
{
return(InlineCall(cb, cbe, istailposition, ppp));
}
}
// cater for varargs more efficiently, this does not seem to hit, probably needed somewhere else, hits in ironscheme-test and cut test
if (mcexpr.Method == Closure_MakeVarArgsX)
{
CodeBlockExpression cbe = mcexpr.Arguments[0] as CodeBlockExpression;
if (ppp.Length < 9 && cbe.Block.ParameterCount <= ppp.Length && !NeedsContext(cbe))
{
// TODO: See why having a context fails here
return(CallVarArgs(cbe, ppp));
}
}
}
if (ex is NewExpression && typeof(ITypedCallable).IsAssignableFrom(ex.Type))
{
NewExpression mcexpr = ex as NewExpression;
CodeBlockExpression cbe = mcexpr.Arguments[0] as CodeBlockExpression;
if (cbe == null && mcexpr.Arguments[0].Type == typeof(CodeContext) && mcexpr.Arguments[0] is ConstantExpression) // implies null
{
cbe = mcexpr.Arguments[1] as CodeBlockExpression;
}
if (cbe != null)
{
var ppp = GetAstListNoCast(c.cdr as Cons, cb);
if (ppp.Length < 9 && cbe.Block.ParameterCount == ppp.Length)
{
return(InlineCall(cb, cbe, istailposition, ppp));
}
}
}
if (ex is ConstantExpression)
{
Builtins.SyntaxError(SymbolTable.StringToObject("generator"), "expecting a procedure", c.car, c);
}
Expression r = null;
if (ex.Type.Name.StartsWith("TypedClosure"))
{
Expression[] pp = GetAstListNoCast(c.cdr as Cons, cb);
var m = ex.Type.GetMethod("Invoke");
//TODO: add more checks, should we attempt some casting for types?
if (m.GetParameters().Length != pp.Length)
{
Builtins.SyntaxError(SymbolTable.StringToObject("apply-typed-lambda"),
string.Format("incorrect number of parameters, expected {0} got {1}", m.GetParameters().Length, pp.Length),
c.car, c);
}
r = Ast.SimpleCallHelper(ex, m, pp);
}
else
{
Expression[] pp = GetAstList(c.cdr as Cons, cb);
if (ex.Type != typeof(Callable))
{
ex = Ast.ConvertHelper(ex, typeof(Callable));
}
MethodInfo call = GetCallable(pp.Length);
r = pp.Length > 8 ?
Ast.Call(ex, call, Ast.NewArray(typeof(object[]), pp)) :
Ast.Call(ex, call, pp);
}
if (spanHint.IsValid)
{
r.SetLoc(spanHint);
}
return(r);
}
object[] v = args as object[];
if (v != null)
{
return(GetConsVector(v, cb));
}
else if (args is byte[])
{
Expression[] ba = Array.ConvertAll(args as byte[], b => Ast.Constant(b));
return(Ast.NewArray(typeof(byte[]), ba));
}
else
{
if (args is SymbolId)
{
SymbolId sym = (SymbolId)args;
if (sym == SymbolTable.StringToId("uninitialized"))
{
return(Ast.ReadField(null, typeof(Uninitialized), "Instance"));
}
else
{
return(Read(sym, cb, typeof(object)));
}
}
if (args == Builtins.Unspecified)
{
return(Ast.ReadField(null, Unspecified));
}
if (args is Fraction)
{
Fraction f = (Fraction)args;
return(Ast.Constant(new FractionConstant(f)));
}
if (args is ComplexFraction)
{
ComplexFraction f = (ComplexFraction)args;
return(Ast.Constant(new ComplexFractionConstant(f)));
}
if (args != null && args.GetType().Name == "stx")
{
args = new SerializedConstant(args);
}
return(Ast.Constant(args));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MenuGenerator" /> class.
/// </summary>
/// <param name="menu">The menu.</param>
/// <param name="generator">The menu preset.</param>
public MenuGenerator(Menu menu, IGenerator generator)
{
this.Generator = generator;
this.Menu = menu;
}
public bool CanPlace(Floor floor, Coord pos, IGenerator rng)
{
return(_generator.CanPlace(floor, pos, rng));
}
public static IGenerator <IEnumerable <T> > Window <T>(this IGenerator <T> generator, int windowSize)
{
return(WindowImpl(generator, windowSize).ToGenerator());
}
public static IGenerator <T> OfType <T>(this IGenerator generator) where T : class
{
return(OfTypeImpl <T>(generator).ToGenerator());
}
public ConstantGaussianMutation(OptimizationProblem problem, double standardDeviation, IGenerator randomNumberGenerator)
{
//problem.CheckInput();
this.continuousVariablesCount = problem.Dimension;
if (standardDeviation <= 0)
{
throw new ArgumentException("Standard deviation must be > 0, but was " + standardDeviation);
}
this.standardDeviations = new double[continuousVariablesCount];
for (int i = 0; i < problem.Dimension; ++i)
{
this.standardDeviations[i] = standardDeviation;
}
if (randomNumberGenerator == null)
{
throw new ArgumentException("The random number generator must not be null");
}
this.normalDistribution = new NormalDistribution(randomNumberGenerator, 0, 1);
}
// You can also define your own extension methods
// for making new generators from existing ones.
// This method turns a generator that generates arbitrary
// elements into a generator that generates the same elements
// converted to strings using ToString
public static IGenerator <string> ElementsToString <T>(this IGenerator <T> source)
{
return(source.Select(x => x.ToString()));
}
public override void Accept(IGenerator generator)
{
generator.Visit(this);
}
public static Move[] NextMoves(this IGenerator rnd) => nextMoves[rnd.Next(24)];
public Layer(IGenerator terrainGenerator, int startingHeight)
{
this.startingHeight = startingHeight;
this.terrainGenerator = terrainGenerator;
}
public static IGenerator <T> RepeatWithProbability <T>(this IGenerator <T> generator, float probability)
{
//asset probability is between 0 and 1
return(RepeatWithProbabilityImlp(generator, probability).ToGenerator());
}
public GeneratorProfile(string name, IGenerator generator)
{
Name = name;
Generator = generator;
}
public Specification(IGenerator <T> generator)
{
Generator = generator;
}
public NullableGenerator(IGenerator <T> generator)
{
this.generator = generator;
}
public NormalDistribution(IGenerator <double> random)
{
Debug.Assert(random != null);
_random = random;
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.activityCode);
_progressBar = FindViewById <ProgressBar>(Resource.Id.progressBar);
_codeTextView = FindViewById <TextView>(Resource.Id.textCode);
_animationScale = Settings.Global.GetFloat(ContentResolver, Settings.Global.AnimatorDurationScale, 1.0f);
var usernameText = FindViewById <TextView>(Resource.Id.textUsername);
var username = Intent.Extras.GetString("username");
if (String.IsNullOrEmpty(username))
{
var issuer = Intent.Extras.GetString("issuer");
usernameText.Text = issuer;
}
else
{
usernameText.Text = username;
}
var iconView = FindViewById <ImageView>(Resource.Id.imageIcon);
var hasCustomIcon = Intent.Extras.GetBoolean("hasCustomIcon");
if (hasCustomIcon)
{
var bitmap = (Bitmap)Intent.Extras.GetParcelable("icon");
if (bitmap != null)
{
iconView.SetImageBitmap(bitmap);
}
else
{
iconView.SetImageResource(IconResolver.GetService(IconResolver.Default, true));
}
}
else
{
iconView.SetImageResource(IconResolver.GetService(Intent.Extras.GetString("icon"), true));
}
_period = Intent.Extras.GetInt("period");
_digits = Intent.Extras.GetInt("digits");
var algorithm = (HashAlgorithm)Intent.Extras.GetInt("algorithm");
var secret = Intent.Extras.GetString("secret");
var type = (AuthenticatorType)Intent.Extras.GetInt("type");
_generator = type switch
{
AuthenticatorType.MobileOtp => new MobileOtp(secret, _digits),
AuthenticatorType.SteamOtp => new SteamOtp(secret),
_ => new Totp(secret, _period, algorithm, _digits)
};
_timer = new Timer
{
Interval = 1000,
AutoReset = true
};
_timer.Elapsed += Tick;
}
/// <summary>
/// Trims current small dead-end paths from the given list of map areas, and removes them from the given map.
/// </summary>
/// <param name="map">Map to remove-dead-end paths from.</param>
/// <param name="areas">Map areas to check for dead ends. Dead ends not contained as one of these map areas will be ignored.</param>
/// <param name="saveDeadEndChance">The chance out of 100 that a given dead end is left alone. Defaults to 0.</param>
/// <param name="rng">Rng to use. Defaults to <see cref="SingletonRandom.DefaultRNG"/>.</param>
public static void Trim(ISettableMapView <bool> map, IEnumerable <MapArea> areas, int saveDeadEndChance = 100, IGenerator rng = null)
{
if (rng == null)
{
rng = SingletonRandom.DefaultRNG;
}
foreach (var area in areas)
{
HashSet <Coord> safeDeadEnds = new HashSet <Coord>();
HashSet <Coord> deadEnds = new HashSet <Coord>();
while (true)
{
foreach (var point in area.Positions)
{
var points = AdjacencyRule.EIGHT_WAY.NeighborsClockwise(point).ToArray();
var directions = AdjacencyRule.EIGHT_WAY.DirectionsOfNeighborsClockwise(Direction.NONE).ToList();
for (int i = 0; i < 8; i += 2)
{
if (map[points[i]])
{
var oppDir = directions[i] + 4;
bool found = false;
// If we get here, source direction is a floor, opposite direction
// should be wall
if (!map[points[(int)oppDir.Type]])
{
switch (oppDir.Type)
{
// Check for a wall pattern in the map. In this case
// something like where X is a wall XXX X X
case Direction.Types.UP:
found = !map[points[(int)Direction.Types.UP_LEFT]] &&
!map[points[(int)Direction.Types.UP_RIGHT]] &&
!map[points[(int)Direction.Types.LEFT]] &&
!map[points[(int)Direction.Types.RIGHT]];
break;
case Direction.Types.DOWN:
found = !map[points[(int)Direction.Types.DOWN_LEFT]] &&
!map[points[(int)Direction.Types.DOWN_RIGHT]] &&
!map[points[(int)Direction.Types.LEFT]] &&
!map[points[(int)Direction.Types.RIGHT]];
break;
case Direction.Types.RIGHT:
found = !map[points[(int)Direction.Types.UP_RIGHT]] &&
!map[points[(int)Direction.Types.DOWN_RIGHT]] &&
!map[points[(int)Direction.Types.UP]] &&
!map[points[(int)Direction.Types.DOWN]];
break;
case Direction.Types.LEFT:
found = !map[points[(int)Direction.Types.UP_LEFT]] &&
!map[points[(int)Direction.Types.DOWN_LEFT]] &&
!map[points[(int)Direction.Types.UP]] &&
!map[points[(int)Direction.Types.DOWN]];
break;
}
}
if (found)
{
deadEnds.Add(point);
}
break;
}
}
}
deadEnds.ExceptWith(safeDeadEnds); // Remove safeDeadEnds from deadEnds
area.Remove(deadEnds); // Remove dead ends from positions
if (deadEnds.Count == 0)
{
break;
}
foreach (var point in deadEnds)
{
if (PercentageCheck(saveDeadEndChance, rng))
{
safeDeadEnds.Add(point);
}
else
{
map[point] = false;
}
}
deadEnds.Clear();
break; // We only do 1 pass, to avoid erasing the entire map.
}
}
}
public static ulong NextCell(this IGenerator rnd) => rnd.Next(10) == 0 ? 2UL : 1UL;
public FunctorEqualsGeneratorPredicate(IFunctor lhs, IGenerator rhs)
{
functor = lhs;
generator = rhs;
}
public MaintenanceService(IFhirService _fhirServiceFull, ILocalhost localhost, IGenerator keyGenerator, IFhirStoreAdministration fhirStoreAdministration, IFhirIndex fhirIndex)
{
this._fhirServiceFull = _fhirServiceFull;
this.localhost = localhost;
this.keyGenerator = keyGenerator;
this.fhirStoreAdministration = fhirStoreAdministration;
this.fhirIndex = fhirIndex;
}
public bool CanGenerate(Floor floor, RoomConnection connectAt, IGenerator rng)
{
MapArea mapArea = GenerateArea(floor.MapInfo, connectAt, rng);
return(floor.MapInfo.Map.Terrain.AllEmpty(mapArea.Positions));
}
public static IGenerator <T> Cast <T>(this IGenerator generator)
{
return(CastImpl <T>(generator).ToGenerator());
}
public ConstantGaussianMutation(OptimizationProblem problem, double[] standardDeviations, IGenerator randomNumberGenerator)
{
//problem.CheckInput();
this.continuousVariablesCount = problem.Dimension;
if (standardDeviations.Length != continuousVariablesCount)
{
throw new ArgumentException("There are " + continuousVariablesCount + " continuous design variables, but "
+ standardDeviations.Length + " standard deviations are provided");
}
this.standardDeviations = new double[continuousVariablesCount];
for (int i = 0; i < problem.Dimension; ++i)
{
if (standardDeviations[i] <= 0)
{
throw new ArgumentException("Standard deviations must be > 0, but at index " + i
+ ", the provided value is " + standardDeviations[i]);
}
this.standardDeviations[i] = standardDeviations[i];
}
if (randomNumberGenerator == null)
{
throw new ArgumentException("The random number generator must not be null");
}
this.normalDistribution = new NormalDistribution(randomNumberGenerator, 0, 1);
}
