/// <summary>
/// Creates a for generate statement.
/// </summary>
/// <param name="label">the label</param>
/// <param name="loopParameter">the identifier of the for loop parameter</param>
/// <param name="range">the loop range</param>
public ForGenerateStatement(string label, string loopParameter, DiscreteRange range)
{
Label = label;
resolvable = new ResolvableImpl(this);
scope = Scopes.createScope(this, resolvable);
this.loopParameter = new Constant(loopParameter, Standard.INTEGER);
this.range = range;
}
public static void FormRange(DiscreteRange range, VHDLCompilerInterface compiler, out string RangeType, out List <string> Parameters)
{
if (range is Range)
{
FormIntegerRange(range as Range, compiler, out RangeType, out Parameters);
return;
}
throw new NotImplementedException();
}
protected static void ValidateRange(double value, DiscreteRange <double> range, string name)
{
if (value < range.Minimum || value > range.Maximum)
{
throw new ArgumentOutOfRangeException(
name,
String.Format(
"The specified value ({1}) must be in the range: {0} ≤ {1} ≤ {2}",
range.Minimum,
name,
range.Maximum));
}
}
public ResolvedDiscreteRange [] ResolveRange(DiscreteRange range)
{
if (range is Range)
{
return new ResolvedDiscreteRange [] { ResolveSimpleRange(range as Range) }
}
;
if (range is SubtypeDiscreteRange)
{
return(ResolveRange(range as SubtypeDiscreteRange));
}
return(null);
}
public void visit(Slice name)
{
output.writeExpression(name.Prefix);
writer.Append('(');
for (int i = 0; i < name.Ranges.Count; i++)
{
DiscreteRange r = name.Ranges[i];
output.writeDiscreteRange(r);
if (i < name.Ranges.Count - 1)
{
writer.Append(", ");
}
}
writer.Append(')');
}
/// <summary>
/// Writes a discrete range.
/// </summary>
/// <param name="range">the discrete range</param>
public virtual void writeDiscreteRange(DiscreteRange range)
{
if (range is Range)
{
getMiscellaneousElementOutput().range((Range)range);
}
else if (range is RangeAttributeName)
{
getMiscellaneousElementOutput().rangeAttributeName((RangeAttributeName)range);
}
else if (range is SubtypeDiscreteRange)
{
getMiscellaneousElementOutput().subtypeDiscreteRange((SubtypeDiscreteRange)range);
}
else if (range == null)
{
//ignore
}
else
{
throw new ArgumentException("Unknown range.");
}
}
public static Part CreateSlice(DiscreteRange range)
{
return(new SlicePart(range));
}
public SlicePart(DiscreteRange range)
: base(TypeEnum.SLICE)
{
this.range = range;
}
public override T CorrectValue(T value)
{
return(DiscreteRange.CorrectValue(value));
}
/// <summary>
/// T'RIGHTOF(X) is the value of discrete type T that is right of X.
/// </summary>
/// <param name="X"></param>
/// <returns></returns>
public virtual T RIGHTOF(T X)
{
return(DiscreteRange.RIGHTOF(X));
}
/// <summary>
/// T'LEFTOF(X) is the value of discrete type T that is left of X.
/// </summary>
/// <param name="X"></param>
/// <returns></returns>
public virtual T LEFTOF(T X)
{
return(DiscreteRange.LEFTOF(X));
}
/// <summary>
/// T'PRED(X) is the value of discrete type T that is the predecessor of X.
/// </summary>
/// <param name="X"></param>
/// <returns></returns>
public virtual T PRED(T X)
{
return(DiscreteRange.PRED(X));
}
/// <summary>
/// T'SUCC(X) is the value of discrete type T that is the successor of X.
/// </summary>
/// <param name="X"></param>
/// <returns></returns>
public virtual T SUCC(T X)
{
return(DiscreteRange.SUCC(X));
}
/// <summary>
/// T'POS(X) is the integer position of X in the discrete type T.
/// </summary>
/// <param name="X"></param>
/// <returns></returns>
public virtual VHDLIntegerValue POS(T X)
{
return(DiscreteRange.POS(X));
}
public static T Random <T>(params DiscreteRange <double>[] values) where T : ColorSpace, new()
{
if (values == null)
{
throw new ArgumentNullException(nameof(values), "The property list cannot be null");
}
if (values.Length < 3 || values.Length > 4)
{
throw new ArgumentException($"No ColorSpace types exist that have {values.Length} properties");
}
if (values.Length == 4 && typeof(T) != typeof(Cmyk) && typeof(T) != typeof(Rgba))
{
throw new ArgumentException("Only Cmyk has 4 color properties");
}
var properties = new decimal[values.Length];
for (var i = 0; i < values.Length; i++)
{
var range = new DiscreteRange <decimal>(
(decimal)values[i].Minimum,
(decimal)values[i].Maximum,
(decimal)values[i].Increment);
if (range.Minimum > range.Maximum)
{
throw new ArgumentOutOfRangeException(
$"Property #{i + 1}",
"Specified minimum cannot be greater than specified maximum");
}
if (range.Increment < 0)
{
throw new ArgumentOutOfRangeException($"Property #{i + 1}", "Given increment cannot be negative");
}
if (range.Minimum != range.Maximum && range.Increment == 0)
{
throw new ArgumentException(
"The specified increment cannot be zero for ranges where minimum ≠ maximum",
$"Property #{i + 1}");
}
properties[i] = range.Minimum == range.Maximum
? range.Minimum
: range.Minimum + Rand.Next((int)((range.Maximum - range.Minimum) / range.Increment) + 1) * range.Increment;
}
var result = new T
{
[0] = Decimal.ToDouble(properties[0]),
[1] = Decimal.ToDouble(properties[1]),
[2] = Decimal.ToDouble(properties[2])
};
if (result is Cmyk)
{
result[3] = Decimal.ToDouble(properties[3]);
}
else if (result is Rgba)
{
result[3] = Decimal.ToDouble(properties[3]);
}
return(result);
}
/// <summary>
/// Creates a for loop.
/// </summary>
/// <param name="loopParameter">the identifier of the loop parameter</param>
/// <param name="range">the loop range</param>
public ForStatement(string loopParameter, DiscreteRange range)
{
scope = Scopes.createScope(this, new ResolvableImpl(this));
this.loopParameter = new Constant(loopParameter, Standard.INTEGER);
this.range = range;
}
