public override SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context) { var model = new DiodeModel(id); SetParameters(context, model, parameters); return(model); }
public override SpiceSharp.Components.Component Generate(string name, string originalName, string type, ParameterCollection parameters, ICircuitContext context) { var losslessLine = new LosslessTransmissionLine(name); context.CreateNodes(losslessLine, parameters); parameters = parameters.Skip(4); foreach (Parameter parameter in parameters) { if (parameter is AssignmentParameter ap) { var paramName = ap.Name.ToLower(); if (paramName == "z0" || paramName == "zo") { context.SetParameter(losslessLine, "z0", ap.Value); } else if (paramName == "f") { context.SetParameter(losslessLine, "f", ap.Value); } else if (paramName == "td") { context.SetParameter(losslessLine, "td", ap.Value); } else if (paramName == "reltol") { context.SetParameter(losslessLine, "reltol", ap.Value); } else if (paramName == "abstol") { context.SetParameter(losslessLine, "abstol", ap.Value); } else { context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Invalid parameter: {parameter.Image}", parameter.LineInfo)); } } } return(losslessLine); }
private static void CreateRowInPrint(ref int rowIndex, Simulation simulation, ICircuitContext context, ExportDataEventArgs eventArgs, List <Export> exports, Print print) { Row row = new Row(rowIndex++); double x = 0; if (simulation is Transient) { x = eventArgs.Time; } if (simulation is AC) { x = eventArgs.Frequency; } if (simulation is DC dc) { if (dc.Sweeps.Count > 1) { // TODO: Add support for DC Sweeps > 1 context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, ".PRINT doesn't support sweep count > 1")); return; } x = eventArgs.SweepValue; } if (!(simulation is OP)) { row.Columns.Add(x); } for (var i = 0; i < exports.Count; i++) { try { double val = exports[i].Extract(); row.Columns.Add(val); } catch (Exception) { row.Columns.Add(double.NaN); } } print.Rows.Add(row); }
public static void SetServiceName(this ICircuitContext context, string serviceName) { context.Set(KeyServiceName, serviceName); }
public override SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context) { SpiceSharp.Components.Model model = null; switch (type.ToLower()) { case "sw": model = new VoltageSwitchModel(id); break; case "csw": model = new CurrentSwitchModel(id); break; case "vswitch": model = new VSwitchModel(id); break; case "iswitch": model = new ISwitchModel(id); break; } if (model != null) { SetParameters(context, model, parameters); } return(model); }
/// <summary> /// Reads <see cref="Control"/> statement and modifies the context /// </summary> /// <param name="statement">A statement to process</param> /// <param name="context">A context to modify</param> public override void Read(Control statement, ICircuitContext context) { foreach (var param in statement.Parameters) { if (param is Models.Netlist.Spice.Objects.Parameters.AssignmentParameter a) { string name = a.Name.ToLower(); string value = a.Value; switch (name) { case "abstol": context.Result.SimulationConfiguration.AbsoluteTolerance = context.Evaluator.EvaluateDouble(value); break; case "reltol": context.Result.SimulationConfiguration.RelTolerance = context.Evaluator.EvaluateDouble(value); break; case "gmin": context.Result.SimulationConfiguration.Gmin = context.Evaluator.EvaluateDouble(value); break; case "itl1": context.Result.SimulationConfiguration.DCMaxIterations = (int)context.Evaluator.EvaluateDouble(value); break; case "itl2": context.Result.SimulationConfiguration.SweepMaxIterations = (int)context.Evaluator.EvaluateDouble(value); break; case "itl4": context.Result.SimulationConfiguration.TranMaxIterations = (int)context.Evaluator.EvaluateDouble(value); break; case "itl5": // TODO: ???? break; case "temp": double temp = context.Evaluator.EvaluateDouble(value) + Constants.CelsiusKelvin; context.Result.SimulationConfiguration.TemperaturesInKelvinsFromOptions = temp; context.Result.SimulationConfiguration.TemperaturesInKelvins.Add(temp); break; case "tnom": context.Result.SimulationConfiguration.NominalTemperatureInKelvins = context.Evaluator.EvaluateDouble(value) + Constants.CelsiusKelvin; break; case "method": switch (value.ToLower()) { case "trap": case "trapezoidal": context.Result.SimulationConfiguration.Method = new Trapezoidal(); break; case "gear": context.Result.SimulationConfiguration.Method = new Gear(); break; case "euler": context.Result.SimulationConfiguration.Method = new FixedEuler(); break; } break; case "seed": var seed = int.Parse(value); context.Result.SimulationConfiguration.Seed = seed; context.Evaluator.Seed = seed; break; case "distribution": context.Evaluator.GetEvaluationContext().Randomizer.CurrentPdfName = value; break; case "cdfpoints": var points = (int)context.Evaluator.EvaluateDouble(value); if (points < 4) { context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "CDFPOINTS needs to be greater than 3", statement.LineInfo)); return; } context.Evaluator.GetEvaluationContext().Randomizer.CdfPoints = points; break; case "normallimit": context.Evaluator.GetEvaluationContext().Randomizer.NormalLimit = context.Evaluator.EvaluateDouble(value); break; default: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported option: {name}", statement.LineInfo)); break; } } if (param is Models.Netlist.Spice.Objects.Parameters.WordParameter w) { if (w.Image.ToLower() == "keepopinfo") { context.Result.SimulationConfiguration.KeepOpInfo = true; } if (w.Image.ToLower() == "dynamic-resistors") { context.Result.SimulationConfiguration.DynamicResistors = true; } } } }
public static void SetAppName(this ICircuitContext context, string appName) { context.Set(KeyAppName, appName); }
public abstract IEntity Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context);
public override Model Generate(string id, string type, SpiceSharpParser.Models.Netlist.Spice.Objects.ParameterCollection parameters, ICircuitContext context) { BipolarJunctionTransistorModel model = new BipolarJunctionTransistorModel(id); if (type.ToLower() == "npn") { model.SetParameter("npn", true); } else if (type.ToLower() == "pnp") { model.SetParameter("pnp", true); } SetParameters(context, model, parameters); return(new Model(id, model, model.Parameters)); }
public override SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context) { BipolarJunctionTransistorModel model = new BipolarJunctionTransistorModel(id); if (type.ToLower() == "npn") { model.SetParameter("npn", true); } else if (type.ToLower() == "pnp") { model.SetParameter("pnp", true); } SetParameters(context, model, parameters); return(model); }
public abstract SpiceSharp.Components.Model Generate(string id, string type, ParameterCollection parameters, ICircuitContext context);
/// <summary> /// Reads <see cref="Control"/> statement and modifies the context. /// </summary> /// <param name="statement">A statement to process.</param> /// <param name="context">A context to modify.</param> public override void Read(Control statement, ICircuitContext context) { CreateSimulations(statement, context, CreateDCSimulation); }
public EnableStochasticModelsSimulationDecorator(ICircuitContext context) { _context = context; }
/// <summary> /// Reads <see cref="Control"/> statement and modifies the context. /// </summary> /// <param name="statement">A statement to process.</param> /// <param name="context">A context to modify.</param> public override void Read(Control statement, ICircuitContext context) { Read(statement, context.Evaluator.GetEvaluationContext(), context.Result.Validation, true); }
/// <summary> /// Generates a new waveform. /// </summary> /// <param name="parameters">Parameters for waveform.</param> /// <param name="context">A context.</param> /// <returns> /// A new waveform. /// </returns> public abstract Waveform Generate(ParameterCollection parameters, ICircuitContext context);
public SpiceSharp.Components.Component Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context) { BipolarJunctionTransistor bjt = new BipolarJunctionTransistor(componentIdentifier); // If the component is of the format QXXX NC NB NE MNAME off we will insert NE again before the model name if (parameters.Count == 5 && parameters[4] is WordParameter w && w.Image == "off") { parameters.Insert(3, parameters[2]); } // If the component is of the format QXXX NC NB NE MNAME we will insert NE again before the model name if (parameters.Count == 4) { parameters.Insert(3, parameters[2]); } context.CreateNodes(bjt, parameters); if (parameters.Count < 5) { context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Wrong parameters count for BJT", parameters.LineInfo)); return(null); } context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) => { context.ModelsRegistry.SetModel( bjt, simulation, parameters.Get(4), $"Could not find model {parameters.Get(4)} for BJT {originalName}", (BipolarJunctionTransistorModel model) => bjt.Model = model.Name, context.Result); }); for (int i = 5; i < parameters.Count; i++) { var parameter = parameters[i]; if (parameter is SingleParameter s) { if (s is WordParameter) { switch (s.Image.ToLower()) { case "on": bjt.SetParameter("off", false); break; case "off": bjt.SetParameter("on", false); break; default: throw new System.Exception(); } } else { // TODO: Fix this please it's broken ... BaseParameters bp = bjt.ParameterSets.Get <BaseParameters>(); if (!bp.Area.Given) { bp.Area.Value = context.Evaluator.EvaluateDouble(s.Image); } if (!bp.Temperature.Given) { bp.Temperature.Value = context.Evaluator.EvaluateDouble(s.Image); } } } if (parameter is AssignmentParameter asg) { if (asg.Name.ToLower() == "ic") { context.SetParameter(bjt, "ic", asg.Value); } } } return(bjt); }
protected void SetSweepSimulation(ICircuitContext context, List <KeyValuePair <Parameter, double> > parameterValues, BaseSimulation simulation) { ParameterUpdater.Update(simulation, context, parameterValues); }
public SpiceSharp.Components.Component Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context) { if (parameters.Count < 4) { throw new System.Exception("Model expected"); } JFET jfet = new JFET(componentIdentifier); context.CreateNodes(jfet, parameters); context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) => { context.ModelsRegistry.SetModel( jfet, simulation, parameters.Get(3), $"Could not find model {parameters.Get(3)} for JFET {originalName}", (JFETModel model) => jfet.Model = model.Name, context.Result); }); // Read the rest of the parameters for (int i = 3; i < parameters.Count; i++) { if (parameters[i] is WordParameter w) { if (w.Image.ToLower() == "off") { jfet.SetParameter("off", true); } } if (parameters[i] is AssignmentParameter asg) { if (asg.Name.ToLower() == "ic") { if (asg.Value.Length == 2) { context.SetParameter(jfet, "ic-vds", asg.Values[0]); context.SetParameter(jfet, "ic-vgs", asg.Values[1]); } if (asg.Value.Length == 1) { context.SetParameter(jfet, "ic-vds", asg.Values[0]); } } else if (asg.Name.ToLower() == "temp") { context.SetParameter(jfet, "temp", asg.Value); } else if (asg.Name.ToLower() == "area") { context.SetParameter(jfet, "area", asg.Value); } else { throw new System.Exception("Unknown parameter: " + asg.Name); } } if (parameters[i] is ValueParameter || parameters[i] is ExpressionParameter) { context.SetParameter(jfet, "area", parameters[i].Image); } } return(jfet); }
public static T Get <T>(this ICircuitContext context, string name) { var result = context.Get(name); return(result == null ? default(T) : (T)result); }
public override IEntity Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context) { switch (type.ToLower()) { case "v": return(GenerateVoltageSource(componentIdentifier, parameters, context)); case "h": return(GenerateCurrentControlledVoltageSource(componentIdentifier, parameters, context)); case "e": return(GenerateVoltageControlledVoltageSource(componentIdentifier, parameters, context)); } return(null); }
public static string GetAppName(this ICircuitContext context) { return(context.Get <string>(KeyAppName)); }
protected void SetSourceParameters( ParameterCollection parameters, ICircuitContext context, Component component) { var originalParameters = parameters; parameters = parameters.Skip(VoltageSource.PinCount); var acParameter = parameters.FirstOrDefault(p => p.Image.ToLower() == "ac"); if (acParameter != null) { int acParameterIndex = parameters.IndexOf(acParameter); if (acParameterIndex != parameters.Count - 1) { var acParameterValue = parameters.Get(acParameterIndex + 1); context.SetParameter(component, "acmag", acParameterValue); if (acParameterIndex + 1 != parameters.Count - 1) { // Check first if next parameter is waveform var acPhaseCandidate = parameters[acParameterIndex + 2].Image; if (parameters[acParameterIndex + 2] is SingleParameter && !context.WaveformReader.Supports(acPhaseCandidate, context) && acPhaseCandidate.ToLower() != "dc") { var acPhaseParameterValue = parameters.Get(acParameterIndex + 2); context.SetParameter(component, "acphase", acPhaseParameterValue); parameters.RemoveAt(acParameterIndex + 2); } } parameters.RemoveAt(acParameterIndex + 1); } parameters.RemoveAt(acParameterIndex); } // 2. Set DC var dcParameter = parameters.FirstOrDefault(p => p.Image.ToLower() == "dc"); if (dcParameter != null) { int dcParameterIndex = parameters.IndexOf(dcParameter); if (dcParameterIndex != parameters.Count - 1) { var dcParameterValue = parameters.Get(dcParameterIndex + 1); context.SetParameter(component, "dc", dcParameterValue); parameters.RemoveAt(dcParameterIndex + 1); } parameters.RemoveAt(dcParameterIndex); } else { if (parameters.Count > 0 && parameters[0] is SingleParameter sp && !context.WaveformReader.Supports(sp.Image, context) && parameters[0].Image.ToLower() != "value") { context.SetParameter(component, "dc", sp); parameters.RemoveAt(0); } } // 3. Set up waveform if (parameters.Count > 0) { var firstParameter = parameters[0]; if (firstParameter is BracketParameter bp) { if (context.WaveformReader.Supports(bp.Name, context)) { component.SetParameter("waveform", context.WaveformReader.Generate(bp.Name, bp.Parameters, context)); } else { context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported waveform: {bp.Name}", bp.LineInfo)); } } else { if (firstParameter is WordParameter wp && wp.Image.ToLower() != "value") { if (context.WaveformReader.Supports(wp.Image, context)) { component.SetParameter("waveform", context.WaveformReader.Generate(wp.Image, parameters.Skip(1), context)); } else { context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported waveform: {wp}", wp.LineInfo)); } } } if (firstParameter is AssignmentParameter ap && ap.Name.ToLower() == "value") { context.SetParameter(component, "dc", ap.Value); } if (parameters.Count >= 2 && parameters[0].Image.ToLower() == "value" && parameters[1] is SingleParameter) { context.SetParameter(component, "dc", parameters[1].Image); } } context.CreateNodes(component, originalParameters); }
public static string GetServiceName(this ICircuitContext context) { return(context.Get <string>(KeyServiceName)); }
/// <summary> /// Generates a waveform from bracket parameter. /// </summary> /// <param name="type">Type.</param> /// <param name="parameters">Parameters.</param> /// <param name="context">A reading context.</param> /// <returns> /// An new instance of waveform. /// </returns> public IWaveformDescription Generate(string type, ParameterCollection parameters, ICircuitContext context) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (!Mapper.TryGetValue(type, context.CaseSensitivity.IsFunctionNameCaseSensitive, out var reader)) { context.Result.Validation.Add( new ValidationEntry( ValidationEntrySource.Reader, ValidationEntryLevel.Warning, $"Unsupported waveform '{type}'", parameters.LineInfo)); return(null); } return(reader.Generate(parameters, context)); }
protected void SetIndependentSource(Entity @entity, BaseSimulation simulation, ICircuitContext context, KeyValuePair <SpiceSharpParser.Models.Netlist.Spice.Objects.Parameter, double> paramToSet) { if (@entity is CurrentSource || @entity is VoltageSource) { context .SimulationPreparations .SetParameter(@entity, simulation, "dc", paramToSet.Value, true, false); } }
public override IEntity Generate(string componentIdentifier, string originalName, string type, SpiceSharpParser.Models.Netlist.Spice.Objects.ParameterCollection parameters, ICircuitContext context) { // Errors switch (parameters.Count) { case 0: context.Result.Validation.Add( new ValidationEntry( ValidationEntrySource.Reader, ValidationEntryLevel.Error, $"Node expected for component {componentIdentifier}", parameters.LineInfo)); return(null); case 1: case 2: case 3: context.Result.Validation.Add( new ValidationEntry( ValidationEntrySource.Reader, ValidationEntryLevel.Error, $"Node expected", parameters.LineInfo)); return(null); case 4: context.Result.Validation.Add( new ValidationEntry( ValidationEntrySource.Reader, ValidationEntryLevel.Error, $"Model name expected", parameters.LineInfo)); return(null); } // Get the model and generate a component for it SpiceSharp.Components.Component mosfet = null; var modelNameParameter = parameters.Get(4); var model = context.ModelsRegistry.FindModel(modelNameParameter.Image); if (model == null) { context.Result.Validation.Add( new ValidationEntry( ValidationEntrySource.Reader, ValidationEntryLevel.Error, $"Could not find model {modelNameParameter.Image} for mosfet {originalName}", parameters.LineInfo)); return(null); } if (Mosfets.ContainsKey(model.GetType())) { var mosfetDetails = Mosfets[model.GetType()].Invoke(componentIdentifier); mosfet = mosfetDetails.Mosfet; context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) => { context.ModelsRegistry.SetModel( mosfetDetails.Mosfet, simulation, modelNameParameter, $"Could not find model {modelNameParameter.Image} for mosfet {componentIdentifier}", mosfetDetails.SetModelAction, context.Result); }); } else { context.Result.Validation.Add( new ValidationEntry( ValidationEntrySource.Reader, ValidationEntryLevel.Error, $"Invalid model {model.GetType()} for {componentIdentifier}", parameters.LineInfo)); return(null); } // The rest is all just parameters context.CreateNodes(mosfet, parameters); SetParameters(context, mosfet, parameters.Skip(5), true); return(mosfet); }
private void RegisterParameter(ParameterCollection parameters, ICircuitContext context) { var variableParameter = parameters[0]; context.Evaluator.SetParameter(variableParameter.Image, 0); }
public IEntity Generate(string componentIdentifier, string originalName, string type, ParameterCollection parameters, ICircuitContext context) { if (parameters.Count < 3) { throw new System.Exception("Model expected"); } Diode diode = new Diode(componentIdentifier); context.CreateNodes(diode, parameters); context.SimulationPreparations.ExecuteActionBeforeSetup((simulation) => { context.ModelsRegistry.SetModel( diode, simulation, parameters.Get(2), $"Could not find model {parameters.Get(2)} for diode {originalName}", (Context.Models.Model model) => diode.Model = model.Name, context.Result); }); // Read the rest of the parameters for (int i = 3; i < parameters.Count; i++) { if (parameters[i] is WordParameter w) { if (w.Image.ToLower() == "on") { diode.SetParameter("off", false); } else if (w.Image.ToLower() == "off") { diode.SetParameter("off", true); } else { throw new System.Exception("Expected on/off for diode"); } } if (parameters[i] is AssignmentParameter asg) { if (asg.Name.ToLower() == "ic") { context.SetParameter(diode, "ic", asg.Value); } } if (parameters[i] is ValueParameter || parameters[i] is ExpressionParameter) { // TODO: Fix this please it's broken ... var bp = diode.GetParameterSet <Parameters>(); if (bp.Area == 0.0) { bp.Area = context.Evaluator.EvaluateDouble(parameters.Get(i)); } else { if (!bp.Temperature.Given) { bp.Temperature = context.Evaluator.EvaluateDouble(parameters.Get(i)); } } } } return(diode); }
/// <summary> /// Generates a new sinusoidal waveform. /// </summary> /// <param name="parameters">A parameter for waveform.</param> /// <param name="context">A context.</param> /// <returns> /// A new waveform. /// </returns> public override IWaveformDescription Generate(ParameterCollection parameters, ICircuitContext context) { if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } if (parameters.Count < 3 || parameters.Count > 6) { context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Wrong parameters count for sine. There must be 3, 4, 5 or 6 parameters", parameters.LineInfo)); } var sine = new Sine(); sine.Offset = context.Evaluator.EvaluateDouble(parameters.Get(0)); sine.Amplitude = context.Evaluator.EvaluateDouble(parameters.Get(1)); sine.Frequency = context.Evaluator.EvaluateDouble(parameters.Get(2)); if (parameters.Count >= 4) { sine.Delay = context.Evaluator.EvaluateDouble(parameters.Get(3)); } if (parameters.Count >= 5) { sine.Theta = context.Evaluator.EvaluateDouble(parameters.Get(4)); } if (parameters.Count == 6) { sine.Phase = context.Evaluator.EvaluateDouble(parameters.Get(5)); } return(sine); }
private Noise CreateNoiseSimulation(string name, Control statement, ICircuitContext context) { Noise noise = null; // Check parameter count switch (statement.Parameters.Count) { case 0: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "SpiceModel expected for .NOISE", statement.LineInfo)); return(null); case 1: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Source expected", statement.LineInfo)); return(null); case 2: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Step type expected", statement.LineInfo)); return(null); case 3: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Number of points expected", statement.LineInfo)); return(null); case 4: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Starting frequency expected", statement.LineInfo)); return(null); case 5: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Stopping frequency expected", statement.LineInfo)); return(null); case 6: break; case 7: break; default: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "Too many parameters for .NOISE", statement.LineInfo)); return(null); } string type = statement.Parameters.Get(2).Image; var numberSteps = context.Evaluator.EvaluateDouble(statement.Parameters.Get(3)); var start = context.Evaluator.EvaluateDouble(statement.Parameters.Get(4)); var stop = context.Evaluator.EvaluateDouble(statement.Parameters.Get(5)); Sweep <double> sweep; switch (type) { case "lin": sweep = new LinearSweep(start, stop, (int)numberSteps); break; case "oct": sweep = new OctaveSweep(start, stop, (int)numberSteps); break; case "dec": sweep = new DecadeSweep(start, stop, (int)numberSteps); break; default: context.Result.Validation.Add(new ValidationEntry(ValidationEntrySource.Reader, ValidationEntryLevel.Warning, "LIN, DEC or OCT expected", statement.LineInfo)); return(null); } // The first parameters needs to specify the output voltage if (statement.Parameters[0] is BracketParameter bracket) { if (bracket.Name.ToLower() == "v") { switch (bracket.Parameters.Count) { // V(A, B) - V(vector) // V(A) - V(singleParameter) case 1: if (bracket.Parameters[0] is VectorParameter v && v.Elements.Count == 2) { var output = v.Elements[0].Image; var reference = v.Elements[1].Image; var input = statement.Parameters[2].Image; noise = new Noise(name, output, reference, input, sweep); } else if (bracket.Parameters[0] is SingleParameter s) { var output = s.Image; var input = statement.Parameters[1].Image; noise = new Noise(name, output, input, sweep); } break;