public override bool Equals(Object obj)
{
//Note: NOT performance critical
if (this == obj)
{
return(true);
}
if (obj == null)
{
return(false);
}
if (GetType() != obj.GetType())
{
return(false);
}
Arc other = (Arc)obj;
if (Ilabel != other.Ilabel)
{
return(false);
}
if (NextState == null)
{
if (other.NextState != null)
{
return(false);
}
}
else if (NextState.GetId() != other.NextState.GetId())
{
return(false);
}
if (Olabel != other.Olabel)
{
return(false);
}
if (!(Weight == other.Weight))
{
if (Float.FloatToIntBits(Weight) != Float.FloatToIntBits(other.Weight))
{
return(false);
}
}
return(true);
}
public bool Equals(Value other)
{
if (Type != other.Type)
{
if (Type == ValueType.Float && other.Type == ValueType.Int || Type == ValueType.Int && other.Type == ValueType.Float)
{
return(Float.Equals(other.Float));
}
}
switch (Type)
{
case ValueType.Unknown:
return(false);
case ValueType.Bool:
return(Bool == other.Bool);
case ValueType.Int:
return(Int == other.Int);
case ValueType.Float:
return(Float.Equals(other.Float));
case ValueType.Float2:
return(Float2.Equals(other.Float2));
case ValueType.Float3:
return(Float3.Equals(other.Float3));
case ValueType.Float4:
return(Float4.Equals(other.Float4));
case ValueType.Quaternion:
return(Quaternion.Equals(other.Quaternion));
case ValueType.Entity:
return(Entity == other.Entity);
case ValueType.StringReference:
return(StringReference.Equals(other.StringReference));
default:
throw new ArgumentOutOfRangeException();
}
}
public static string Print(IValue expression)
{
return(expression switch
{
Boolean boolean => boolean.Value ? "#t" : "#f",
Integer integer => integer.Value.ToString(),
Float floating => AddDotZeroIfInteger(floating.Value.ToString("G7",
CultureInfo.InvariantCulture.NumberFormat)),
Nil _ => "nil",
String @string => $"\"{@string.Value}\"",
Symbol symbol => symbol.Value,
Function _ => "#<function>",
Keyword keyword => keyword.Value,
List list => PrintCollection("(", ")", list),
Vector vector => PrintCollection("[", "]", vector),
_ => throw new YungException(
$"Tried to print a node of type {expression.GetType().Name}, but this action is not implemented.")
});
public override int GetHashCode()
{
unchecked
{
var hashCode = Byte.GetHashCode();
hashCode = (hashCode * 397) ^ Short.GetHashCode();
hashCode = (hashCode * 397) ^ ArrayReaderTestId;
hashCode = (hashCode * 397) ^ Long.GetHashCode();
hashCode = (hashCode * 397) ^ Float.GetHashCode();
hashCode = (hashCode * 397) ^ Double.GetHashCode();
hashCode = (hashCode * 397) ^ Decimal.GetHashCode();
hashCode = (hashCode * 397) ^ Bool.GetHashCode();
hashCode = (hashCode * 397) ^ String.GetHashCode();
hashCode = (hashCode * 397) ^ Guid.GetHashCode();
hashCode = (hashCode * 397) ^ DateTime.GetHashCode();
return(hashCode);
}
}
public static void Save(float saveFloat, string nameKey)
{
Float @float = new Float();
@float.@float = saveFloat;
if (!Directory.Exists(Application.dataPath + "/Saves"))
{
Directory.CreateDirectory(Application.dataPath + "/Saves");
}
FileStream fs = new FileStream(Application.dataPath + "/Saves/" + nameKey + ".sh", FileMode.Create);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, @float);
fs.Close();
}
/**
* Returns the version of the Java virtual machine.
*
* @return the Java virtual machine version.
*/
public static float getJavaVersion()
{
float ver = 0f;
String s = System.getProperty("java.specification.version");
if (null == s || s.length() == 0)
{
s = System.getProperty("java.version");
}
try
{
ver = Float.parseFloat(s.trim());
}
catch (NumberFormatException ignore)
{
}
return(ver);
}
public bool IsFloatValid()
{
bool valid = true;
valid &= !Float.IsNaN(this.val[0]);
valid &= !Float.IsNaN(this.val[1]);
valid &= !Float.IsNaN(this.val[2]);
valid &= !Float.IsNaN(this.val[3]);
valid &= !Float.IsNaN(this.val[4]);
valid &= !Float.IsNaN(this.val[5]);
valid &= !Float.IsNaN(this.val[6]);
valid &= !Float.IsNaN(this.val[7]);
valid &= !Float.IsNaN(this.val[8]);
return(valid);
}
private static int CompareDoubleAgainstRawType(double lhsDouble, long rhsRawBits, sbyte rhsType)
{
if (rhsType == BYTE || rhsType == SHORT || rhsType == INT || rhsType == LONG)
{
return(NumberValues.compareDoubleAgainstLong(lhsDouble, rhsRawBits));
}
else if (rhsType == FLOAT)
{
return(lhsDouble.CompareTo(Float.intBitsToFloat(( int )rhsRawBits)));
}
else if (rhsType == DOUBLE)
{
return(lhsDouble.CompareTo(Double.longBitsToDouble(rhsRawBits)));
}
// We can not throw here because we will visit this method inside a pageCursor.shouldRetry() block.
// Just return a comparison that at least will be commutative.
return(Long.compare(System.BitConverter.DoubleToInt64Bits(lhsDouble), rhsRawBits));
}
private static int CompareLongAgainstRawType(long lhs, long rhsRawBits, sbyte rhsType)
{
if (rhsType == BYTE || rhsType == SHORT || rhsType == INT || rhsType == LONG)
{
return(Long.compare(lhs, rhsRawBits));
}
else if (rhsType == FLOAT)
{
return(NumberValues.compareLongAgainstDouble(lhs, Float.intBitsToFloat(( int )rhsRawBits)));
}
else if (rhsType == DOUBLE)
{
return(NumberValues.compareLongAgainstDouble(lhs, Double.longBitsToDouble(rhsRawBits)));
}
// We can not throw here because we will visit this method inside a pageCursor.shouldRetry() block.
// Just return a comparison that at least will be commutative.
return(Long.compare(lhs, rhsRawBits));
}
public static Float Clamp(Float Val, Float v1, Float v2)
{
if (v1 > v2)
{
var tmv = v1;
v1 = v2;
v2 = tmv;
}
if (v1.iVal <= Val.iVal && Val.iVal <= v2.iVal)
{
return(Val);
}
if (Val.iVal < v1.iVal)
{
return(v1);
}
return(v2);
}
} // write
/*
** Name: write (float) at a position
**
** Description:
** Write a float value in the output buffer.
**
** Input:
** position Buffer position.
** floatValue Float value.
**
** Output:
** None.
**
** Returns:
** void
**
** History:
** 16-Jun-99 (gordy)
** Created.
** 28-Jan-00 (gordy)
** Replaced redundat code with check() method.
** 14-Aug-02 (thoda04)
** Ported for .NET Provider.
*/
/// <summary>
/// Write an float value in the output buffer at a particular position.
/// </summary>
/// <param name="position">Buffer position.</param>
/// <param name="floatValue">float value.</param>
public virtual void write(int position, float floatValue)
{
uint bits, man;
short exp;
byte sign;
check(position, DAM_TL_F4_LEN);
/*
** Extract bits of each component.
*/
bits = Float.floatToIntBits(floatValue);
sign = (byte)((bits & 0x80000000) >> 31);
exp = (short)((bits & 0x7f800000) >> 23);
man = (uint)((bits & 0x007fffff) << 9);
/*
** Re-bias the exponent
*/
if (exp != 0)
{
exp = (short)(exp - (126 - 16382));
}
/*
** Pack the bits in network format.
** (note that byte pairs are swapped).
*/
buffer[position + 1] = (byte)((sign << 7) | (exp >> 8));
buffer[position + 0] = (byte)exp;
buffer[position + 3] = (byte)(man >> 24);
buffer[position + 2] = (byte)(man >> 16);
buffer[position + 5] = (byte)(man >> 8);
buffer[position + 4] = (byte)man;
position += DAM_TL_F4_LEN;
if (position > data_ptr)
{
data_ptr = position;
}
return;
} // write
// REVIEW: Maybe need revamping. As values get closer to 0 , the tolerance needs to increase.
// REVIEW: Every test should be able to override the RelativeToleranceStepSize.
private double GetTolerance(Float value)
{
double stepSizeMultiplier;
if (value == 0)
stepSizeMultiplier = 1;
else
stepSizeMultiplier = Math.Log((double)Math.Abs(value));
if (stepSizeMultiplier <= 0)
{
stepSizeMultiplier = Math.Max(1, Math.Abs(stepSizeMultiplier));
// tolerance needs to increase faster as we start going towards smaller values.
stepSizeMultiplier *= stepSizeMultiplier;
}
else
stepSizeMultiplier = Math.Min(1, 1 / stepSizeMultiplier);
return stepSizeMultiplier * RelativeToleranceStepSize;
}
public override IAlgorithmOutput Withdraw(double amount)
{
if (SufficientFunds(amount))
{
var orderedFloat = Float.OrderByDescending(o => o.Value).ToArray();
var sb = new StringBuilder();
Array.ForEach(orderedFloat, item =>
{
if (amount >= item.Value)
{
int noteCount = (int)Math.Floor(amount / item.Value);
if (noteCount <= item.Total)
{
item.Total -= noteCount;
amount -= noteCount * item.Value;
amount = Math.Round(amount, 2);
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append($"{item.Display} x {noteCount}");
}
}
});
return(new BaseAlgorithmOutput
{
Balance = Balance,
Output = sb.ToString().Trim()
});
}
else
{
return(new BaseAlgorithmOutput
{
Balance = Balance,
Output = "Insufficient funds!"
});
}
}
public void FloatTest()
{
Float minusOne = new Float(-1f);
Float zero = new Float(0f);
Float half = new Float(0.5f);
Float one = new Float(1f);
Float oneHalf = new Float(1.5f);
Float two = new Float(2f);
Assert.AreEqual(zero, mul.Execute(zero, one));
Assert.AreEqual(zero, mul.Execute(zero, two));
Assert.AreEqual(zero, mul.Execute(two, zero));
Assert.AreEqual(one, mul.Execute(one, one));
Assert.AreEqual(two, mul.Execute(two, one));
Assert.AreEqual(new Float(4), mul.Execute(two, two));
Assert.AreEqual(one, mul.Execute(two, half));
Assert.AreEqual(minusOne, mul.Execute(minusOne, one));
}
public Float osList2Double(list src, integer index)
{
if (index >= src.Count)
{
Verbose("osList2Double({0}, {1})={2}", src.ToVerboseString(), index, -1);
return(-1);
}
else if (src[index].GetType() == typeof(string))
{
Verbose("osList2Double({0}, {1})={2}", src.ToVerboseString(), index, float.Parse((string)src[index]));
return((Float)float.Parse((string)src[index]));
}
else
{
Float f = float.Parse(src[index].ToString());
Verbose("osList2Double({0}, {1})={2}", src.ToVerboseString(), index, src[index]);
return(f);
}
}
/// <summary>
/// Initialises a new instance of the <see cref="SecondLife"/> class.
/// </summary>
public SecondLife()
{
this.host = null;
rdmRandom = new Random();
dtDateTimeScriptStarted = DateTime.Now.ToUniversalTime();
htLandPassList = new Hashtable();
htLandBanList = new Hashtable();
fVolume = 0.0;
sObjectName = null;
vPosition = new vector(127, 128, 20);
rRotation = rotation.ZERO_ROTATION;
rRotationlocal = rotation.ZERO_ROTATION;
vScale = vector.ZERO_VECTOR;
sSitText = "sittext";
fSoundRadius = 1.0;
iStartParameter = 0;
vRegionCorner = vector.ZERO_VECTOR;
}
private void Branch(Cylinder parent, Float size)
{
Cylinder branch = new Cylinder();
branch.Texture = Library.Textures.DarkWood;
Vector end = (new PovRandom().Vector() + (-0.5, 0, -0.5)) * (size * 3);
branch.BasePoint = parent.CapPoint;
branch.CapPoint = parent.CapPoint + end;
branch.Radius = size * 0.1;
this.Add(branch);
size = size * 0.5;
if (size > 1)
{
this.AddBranches(branch, size);
}
}
// EaseInOutOver（lenをはみ出すEaseInOut）
// len: 補間の長さ
// sec: 補間時間（秒）
// m : はみ出し強度(0-1)
// deltaCallback< sec, t, dt, delta >
// sec : 経過秒
// t : 経過補間係数（0～1）
// dt : 前回からの差分時間
// delta: 差分値
static public Result easeInOutOver(float len, float sec, float m, System.Func <float, float, float, float, bool> deltaCallback, System.Action finishCallback = null)
{
float preSec = 0.0f;
float m2 = m * 0.2f + 0.8f;
float p = len / (sec * (6.0f * m2 * m2 - 6.0f * m2 + 1.0f));
float a = -2.0f / (sec * sec);
float b = 3.0f / sec;
float c = 6.0f * m2 * (m2 - 1);
var res = new Float(() => {
return(updateTime(ref preSec, len, sec, deltaCallback, finishCallback, (_preSec, _dt) => {
float s = _preSec;
float sd = _preSec + _dt;
return p * (a * (sd * sd * sd - s * s * s) + b * (sd * sd - s * s) + c * (sd - s));
}));
});
DeltaLerpUpdater.getInstance().add(res);
return(res);
}
public override float getProbability(WordSequence wordSequence)
{
int num = wordSequence.size();
if (num > this.maxDepth)
{
string text = new StringBuilder().append("Unsupported NGram: ").append(wordSequence.size()).toString();
throw new Error(text);
}
if (num == this.maxDepth)
{
Float @float = (Float)this.ngramProbCache.get(wordSequence);
if (@float != null)
{
this.ngramHits++;
return(@float.floatValue());
}
this.ngramMisses++;
}
float num2 = this.applyWeights(this.getProbabilityRaw(wordSequence));
if (num == this.maxDepth)
{
this.ngramProbCache.put(wordSequence, Float.valueOf(num2));
}
if (this.logFile != null)
{
PrintWriter printWriter = this.logFile;
StringBuilder stringBuilder = new StringBuilder();
string text2 = wordSequence.toString();
object obj = "][";
object obj2 = " ";
object _ref = obj;
CharSequence charSequence = CharSequence.Cast(_ref);
CharSequence charSequence2 = charSequence;
_ref = obj2;
charSequence = CharSequence.Cast(_ref);
printWriter.println(stringBuilder.append(String.instancehelper_replace(text2, charSequence2, charSequence)).append(" : ").append(Float.toString(num2)).toString());
}
return(num2);
}
public override float getSmear(WordSequence wordSequence)
{
float num = 0f;
if (this.fullSmear)
{
this.smearCount++;
int num2 = wordSequence.size();
if (num2 == 1)
{
int num3 = this.getWordID(wordSequence.getWord(0));
num = this.unigramSmearTerm[num3];
}
else if (num2 >= 2)
{
int num3 = wordSequence.size();
int wordID = this.getWordID(wordSequence.getWord(num3 - 2));
int wordID2 = this.getWordID(wordSequence.getWord(num3 - 1));
Float smearTerm = this.getSmearTerm(wordID, wordID2);
if (smearTerm == null)
{
num = this.unigramSmearTerm[wordID2];
}
else
{
num = smearTerm.floatValue();
this.smearBigramHit++;
}
}
bool flag = this.smearCount != 0;
int num4 = 100000;
if (num4 == -1 || (flag ? 1 : 0) % num4 == 0)
{
[email protected](new StringBuilder().append("Smear hit: ").append(this.smearBigramHit).append(" tot: ").append(this.smearCount).toString());
}
}
if (this.fullSmear && this.logger.isLoggable(Level.FINE))
{
this.logger.fine(new StringBuilder().append("SmearTerm: ").append(num).toString());
}
return(num);
}
static IC()
{
var m = typeof(IC).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static);
foreach (MethodInfo method in m)
{
Type t = method.ReturnType;
string s = method.Name.Substring(1);
int i;
if (!int.TryParse(s, System.Globalization.NumberStyles.Number, CultureInfo.InvariantCulture, out i))
continue;
if (t == typeof(bool))
Bit.Add(i, (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), method));
else if (t == typeof(int))
Basic.Add(i, (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), method));
else if (t == typeof(float))
Float.Add(i, (Func<float>)Delegate.CreateDelegate(typeof(Func<float>), method));
}
}
// ===========================================================
// Getter & Setter
// ===========================================================
// ===========================================================
// Methods for/from SuperClass/Interfaces
// ===========================================================
// ===========================================================
// Methods
// ===========================================================
public /*synchronized*/ void Update(float pX1, float pY1, float pX2, float pY2)
{
lock (_methodLock)
{
int[] bufferData = this.mBufferData;
bufferData[0] = Float.FloatToRawIntBits(pX1);
bufferData[1] = Float.FloatToRawIntBits(pY1);
bufferData[2] = Float.FloatToRawIntBits(pX2);
bufferData[3] = Float.FloatToRawIntBits(pY2);
FastFloatBuffer buffer = this.GetFloatBuffer();
buffer.Position(0);
buffer.Put(bufferData);
buffer.Position(0);
base.SetHardwareBufferNeedsUpdate();
}
}
public void testFloat()
{
var f = new Float(20f);
var cp = f.copy();
Assert.AreEqual(f.get(), 20f);
Assert.AreEqual(f.get(), cp.get());
Assert.AreEqual(f.nulo(), 0f);
f.add(20f);
f.reduce(10f);
Assert.AreEqual(f.get(), 30f);
Assert.AreNotEqual(f.get(), cp.get());
f.mult(10f);
Assert.AreEqual(f.get(), 300f);
f.set(200f);
Assert.AreEqual(f.get(), 200f);
}
public object Apply(object a, object b)
{
return(a switch {
// Integral types
byte bt => Byte?.Invoke(bt, Convert.ToByte(b)),
sbyte sb => SByte?.Invoke(sb, Convert.ToSByte(b)),
short sh => Short?.Invoke(sh, Convert.ToInt16(b)),
ushort ush => UShort?.Invoke(ush, Convert.ToUInt16(b)),
int i => Int?.Invoke(i, Convert.ToInt32(b)),
uint ui => UInt?.Invoke(ui, Convert.ToUInt32(b)),
long l => Long?.Invoke(l, Convert.ToInt64(b)),
ulong ul => ULong?.Invoke(ul, Convert.ToUInt64(b)),
float f => Float?.Invoke(f, Convert.ToSingle(b)),
double d => Double?.Invoke(d, Convert.ToDouble(b)),
decimal dec => Decimal?.Invoke(dec, Convert.ToDecimal(b)),
string str => String?.Invoke(str, Convert.ToString(b)),
DateTime dt => DateTime?.Invoke(dt, TimeUtils.TimeSpanOf(b)),
TimeSpan ts => TimeSpan?.Invoke(ts, b),
_ => throw new ArgumentException($"I don't know how to coercively operate on {a.GetType()} and {b.GetType()}!")
} ?? throw DoesNotApply(a, b));
private static void GetCPUDetails()
{
Java.Lang.Process p;
try
{
p = Runtime.GetRuntime().Exec("cat sys/class/thermal/thermal_zone0/temp");
p.WaitForAsync();
BufferedReader reader = new BufferedReader(new InputStreamReader(p.InputStream));
string line = reader.ReadLine();
float temp = Float.ParseFloat(line) / 1000.0f;
resultStatistic.CpuTemp = temp;
result = "CPU Temp: " + temp.ToString() + "oC\n";
}
catch (System.Exception e)
{
//return 0.0f;
}
}
public override int GetHashCode()
{
unchecked
{
int hashCode = Sbyte.GetHashCode();
hashCode = (hashCode * 397) ^ Short.GetHashCode();
hashCode = (hashCode * 397) ^ Int;
hashCode = (hashCode * 397) ^ Long.GetHashCode();
hashCode = (hashCode * 397) ^ Byte.GetHashCode();
hashCode = (hashCode * 397) ^ UShort.GetHashCode();
hashCode = (hashCode * 397) ^ (int)UInt;
hashCode = (hashCode * 397) ^ ULong.GetHashCode();
hashCode = (hashCode * 397) ^ Char.GetHashCode();
hashCode = (hashCode * 397) ^ Float.GetHashCode();
hashCode = (hashCode * 397) ^ Double.GetHashCode();
hashCode = (hashCode * 397) ^ Decimal.GetHashCode();
hashCode = (hashCode * 397) ^ Boolean.GetHashCode();
return(hashCode);
}
}
protected bool Equals(object other)
{
if (this == other)
{
return(true);
}
if (other == null)
{
return(false);
}
if (GetType() != other.GetType())
{
return(false);
}
var class2 = (Class2)other;
return(Bool == class2.Bool && Byte == class2.Byte && Char == class2.Char && Double.Equals(class2.Double) &&
Float.Equals(class2.Float) && Int == class2.Int && Long == class2.Long && Sbyte == class2.Sbyte &&
Short == class2.Short && UInt == class2.UInt && Ulong == class2.Ulong && Ushort == class2.Ushort);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Id;
hashCode = (hashCode * 397) ^ NullableId.GetHashCode();
hashCode = (hashCode * 397) ^ Byte.GetHashCode();
hashCode = (hashCode * 397) ^ Short.GetHashCode();
hashCode = (hashCode * 397) ^ Int;
hashCode = (hashCode * 397) ^ Long.GetHashCode();
hashCode = (hashCode * 397) ^ UShort.GetHashCode();
hashCode = (hashCode * 397) ^ (int)UInt;
hashCode = (hashCode * 397) ^ ULong.GetHashCode();
hashCode = (hashCode * 397) ^ Float.GetHashCode();
hashCode = (hashCode * 397) ^ Double.GetHashCode();
hashCode = (hashCode * 397) ^ Decimal.GetHashCode();
hashCode = (hashCode * 397) ^ (String != null ? String.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ DateTime.GetHashCode();
hashCode = (hashCode * 397) ^ TimeSpan.GetHashCode();
hashCode = (hashCode * 397) ^ DateTimeOffset.GetHashCode();
hashCode = (hashCode * 397) ^ Guid.GetHashCode();
hashCode = (hashCode * 397) ^ Bool.GetHashCode();
hashCode = (hashCode * 397) ^ Char.GetHashCode();
hashCode = (hashCode * 397) ^ NullableDateTime.GetHashCode();
hashCode = (hashCode * 397) ^ NullableTimeSpan.GetHashCode();
hashCode = (hashCode * 397) ^ (ByteArray != null ? ByteArray.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (CharArray != null ? CharArray.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (StringArray != null ? StringArray.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (IntArray != null ? IntArray.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (LongArray != null ? LongArray.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (StringList != null ? StringList.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (StringMap != null ? StringMap.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (IntStringMap != null ? IntStringMap.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (SubType != null ? SubType.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (SubTypes != null ? SubTypes.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (CustomText != null ? CustomText.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (MaxText != null ? MaxText.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ CustomDecimal.GetHashCode();
return(hashCode);
}
}
public Node Simple()
{
if (CurrentToken == Token.FLOAT)
{
var floa = new Float();
floa.lexeme = lex.curlex;
//floa.lexeme = CurrentToken.lexeme;
Console.WriteLine(floa.lexeme);
//Console.WriteLine(floa.lexeme);
//floa.AnchorToken =
//Console.WriteLine("aqui4");
Expect(Token.FLOAT);
//var exp1 = MaxList();
////console.writeLine(CurrentToken);
return(floa);
}
if (CurrentToken == Token.DUP)
{
var dup = new Dup();
//dup.AnchorToken =
//Console.WriteLine("aqui5");
Expect(Token.DUP);
var exp1 = Simple();
dup.Add(exp1);
return(dup);
}
else if (CurrentToken == Token.OPEN)
{
Expect(Token.OPEN);
var dup = MaxList();
//dup.AnchorToken =
//Console.WriteLine("aqui6");
//xpect(Token.DUP);
Expect(Token.CLOSE);
return(dup);
}
//console.writeLine("aqui");
throw new SyntaxError();
return(null);
}
public void SetValue(Type type, object value)
{
if (type == Type.Bool)
{
m_Bool = (bool)value;
}
else if (type == Type.Int)
{
m_Int = (Int)value;
}
else if (type == Type.Float)
{
m_Float = (Float)value;
}
else if (type == Type.FloatRange)
{
m_FloatRange = (FloatRange)value;
}
else if (type == Type.IntRange)
{
m_IntRange = (IntRange)value;
}
else if (type == Type.RandomFloat)
{
m_RandomFloat = (RandomFloat)value;
}
else if (type == Type.RandomInt)
{
m_RandomInt = (RandomInt)value;
}
else if (type == Type.String)
{
m_String = (string)value;
}
else if (type == Type.None)
{
return;
}
Changed.Send(this);
}
/// <summary>
/// floats a raster
/// </summary>
/// <param name="inRaster">input raster can be a constant, raster, or string (full path)</param>
/// <param name="outRst">string full path</param>
public void floatRaster(object inRaster, string outRst)
{
Float fl = new Float();
fl.in_raster_or_constant = inRaster;
fl.out_raster = outRst;
string rsl = getMessages(gpExecute(fl));
}
public Float(Float xx){
x = xx.x;
}
public static Float test(Float f) {
return ++f;
}
/// <summary> Internal parse method </summary>
/// <param name="parseImplicitMappings">
/// Avoids ethernal loops while parsing implicit mappings. Implicit mappings are
/// not rocognized by a leading character. So while trying to parse the key of
/// something we think that could be a mapping, we're sure that if it is a mapping,
/// the key of this implicit mapping is not a mapping itself.
///
/// NOTE: Implicit mapping still belong to unstable code and require the UNSTABLE and
/// IMPLICIT_MAPPINGS preprocessor flags.
/// </param>
/// <param name="stream"></param>
protected static Node Parse (ParseStream stream, bool parseImplicitMappings)
{
// ----------------
// Skip Whitespace
// ----------------
if (! stream.EOF)
{
// Move the firstindentation pointer after the whitespaces of this line
stream.SkipSpaces ();
while (stream.Char == '\n' && ! stream.EOF)
{
// Skip newline and next whitespaces
stream.Next ();
stream.SkipSpaces ();
}
}
// -----------------
// No remaining chars (Null/empty stream)
// -----------------
if (stream.EOF)
return new Null ();
// -----------------
// Explicit type
// -----------------
#if SUPPORT_EXPLICIT_TYPES
stream.BuildLookaheadBuffer ();
char a = '\0', b = '\0';
a = stream.Char; stream.Next ();
b = stream.Char; stream.Next ();
// Starting with !!
if (a == '!' && b == '!' && ! stream.EOF)
{
stream.DestroyLookaheadBuffer ();
// Read the tagname
string tag = "";
while (stream.Char != ' ' && stream.Char != '\n' && ! stream.EOF)
{
tag += stream.Char;
stream.Next ();
}
// Skip Whitespace
if (! stream.EOF)
{
stream.SkipSpaces ();
while (stream.Char == '\n' && ! stream.EOF)
{
stream.Next ();
stream.SkipSpaces ();
}
}
// Parse
Node n;
switch (tag)
{
// Mappings and sequences
// NOTE:
// - sets are mappings without values
// - Ordered maps are ordered sequence of key: value
// pairs without duplicates.
// - Pairs are ordered sequence of key: value pairs
// allowing duplicates.
// TODO: Create new datatypes for omap and pairs
// derived from sequence with a extra duplicate
// checking.
case "seq": n = new Sequence (stream); break;
case "map": n = new Mapping (stream); break;
case "set": n = new Mapping (stream); break;
case "omap": n = new Sequence (stream); break;
case "pairs": n = new Sequence (stream); break;
// Scalars
//
// TODO: do we have to move this to Scalar.cs
// in order to get the following working:
//
// !!str "...": "..."
// !!str "...": "..."
case "timestamp": n = new Timestamp (stream); break;
case "binary": n = new Binary (stream); break;
case "null": n = new Null (stream); break;
case "float": n = new Float (stream); break;
case "int": n = new Integer (stream); break;
case "bool": n = new Boolean (stream); break;
case "str": n = new String (stream); break;
// Unknown data type
default:
throw new Exception ("Incorrect tag '!!" + tag + "'");
}
return n;
}
else
{
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
}
#endif
// -----------------
// Sequence
// -----------------
if (stream.Char == '-' || stream.Char == '[')
return new Sequence (stream);
// -----------------
// Mapping
// -----------------
if (stream.Char == '?' || stream.Char == '{')
return new Mapping (stream);
// -----------------
// Try implicit mapping
// -----------------
// This are mappings which are not preceded by a question
// mark. The keys have to be scalars.
#if (UNSTABLE && SUPPORT_IMPLICIT_MAPPINGS)
// NOTE: This code can't be included in Mapping.cs
// because of the way we are using to rewind the buffer.
Node key, val;
if (parseImplicitMappings)
{
// First Key/value pair
stream.BuildLookaheadBuffer ();
stream.StopAt (new char [] {':'});
// Keys of implicit mappings can't be sequences, or other mappings
// just look for scalars
key = Scalar.Parse (stream, false);
stream.DontStop ();
Console.WriteLine ("key: " + key);
// Followed by a colon, so this is a real mapping
if (stream.Char == ':')
{
stream.DestroyLookaheadBuffer ();
Mapping mapping = new Mapping ();
// Skip colon and spaces
stream.Next ();
stream.SkipSpaces ();
// Parse the value
Console.Write ("using buffer: " + stream.UsingBuffer ());
stream.Indent ();
Console.Write ("using buffer: " + stream.UsingBuffer ());
// val = Parse (stream, false);
Console.Write ("<<");
while (!stream.EOF) {Console.Write (stream.Char);stream.Next (true);}
Console.Write (">>");
val = new String (stream);
Console.Write ("using buffer: " + stream.UsingBuffer ());
stream.UnIndent ();
Console.Write ("using buffer: " + stream.UsingBuffer ());
Console.Write ("<<");
while (!stream.EOF) {Console.Write (stream.Char);stream.Next (true);}
Console.Write (">>");
Console.WriteLine ("val: " + val);
mapping.AddMappingNode (key, val);
// Skip possible newline
// NOTE: this can't be done by the drop-newline
// method since this is not the end of a block
while (stream.Char == '\n')
stream.Next (true);
// Other key/value pairs
while (! stream.EOF)
{
stream.StopAt (new char [] {':'} );
stream.Indent ();
key = Scalar.Parse (stream);
stream.UnIndent ();
stream.DontStop ();
Console.WriteLine ("key 2: " + key);
if (stream.Char == ':')
{
// Skip colon and spaces
stream.Next ();
stream.SkipSpaces ();
// Parse the value
stream.Indent ();
val = Parse (stream);
stream.UnIndent ();
Console.WriteLine ("val 2: " + val);
mapping.AddMappingNode (key, val);
}
else // TODO: Is this an error?
{
// NOTE: We can't recover from this error,
// the last buffer has been destroyed, so
// rewinding is impossible.
throw new ParseException (stream,
"Implicit mapping without value node");
}
// Skip possible newline
while (stream.Char == '\n')
stream.Next ();
}
return mapping;
}
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
}
#endif
// -----------------
// No known data structure, assume this is a scalar
// -----------------
Scalar scalar = Scalar.Parse (stream);
// Skip trash
while (! stream.EOF)
stream.Next ();
return scalar;
}
public Float2 pow(Float2 asd,Float p){
asd.x = Mathf.Pow(asd.x,p);
asd.y = Mathf.Pow(asd.y,p);
return asd;
}
/// <summary>
/// Parses a scalar
/// <list type="bullet">
/// <item>Integer</item>
/// <item>String</item>
/// <item>Boolean</item>
/// <item>Null</item>
/// <item>Timestamp</item>
/// <item>Float</item>
/// <item>Binary</item>
/// </list>
/// </summary>
/// <remarks>
/// Binary is only parsed behind an explicit !!binary tag (in Node.cs)
/// </remarks>
public static new Scalar Parse (ParseStream stream)
{
// -----------------
// Parse scalars
// -----------------
stream.BuildLookaheadBuffer ();
// Try Null
#if SUPPORT_NULL_NODES
try
{
Scalar s = new Null (stream);
stream.DestroyLookaheadBuffer ();
return s;
} catch { }
#endif
// Try boolean
#if SUPPORT_BOOLEAN_NODES
stream.RewindLookaheadBuffer ();
try
{
Scalar scalar = new Boolean (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
}
catch { }
#endif
// Try integer
#if SUPPORT_INTEGER_NODES
stream.RewindLookaheadBuffer ();
try
{
Scalar scalar = new Integer (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
} catch { }
#endif
// Try Float
#if SUPPORT_FLOAT_NODES
stream.RewindLookaheadBuffer ();
try
{
Scalar scalar = new Float (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
}
catch { }
#endif
// Try timestamp
#if SUPPORT_TIMESTAMP_NODES
stream.RewindLookaheadBuffer ();
try {
Scalar scalar = new Timestamp (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
} catch { }
#endif
// Other scalars are strings
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
return new String (stream);
}
Float DotFalloff( Float xsq ) { xsq = 1.0f - xsq; return xsq.Square().Square(); }
Float DotNoise(Float X,Float Y,Float Val1,Float Val2,Float Val3)
{
Float3 Rad = new Float3(Val1,Val2,Val3);
Float2 P = new Float2(X,Y);
Float radius_low = Rad.x;
Float radius_high = Rad.y;
Float2 Pi = floor(P,true);
Float2 Pf = P-Pi;
Float4 Hash = FastHash2D(Pi);
Float Radius = max(0.0f,radius_low+Hash.z*(radius_high-radius_low),true);
Float Value = Radius/max(radius_high,radius_low,true);
Radius = 2.0f/Radius;
Pf *= Radius;
Pf -= (Radius - 1.0f);
Pf += Hash.xy*(Radius - 2f);
Pf = pow(Pf,Rad.z);
return DotFalloff(min(dot(Pf,Pf),1.0f,true))*Value;
}
public Float3(Float xx){
x = xx.x;
y = xx.x;
z = xx.x;
}
public Float3(Float xx,Float yy,Float zz){
x = xx.x;
y = yy.x;
z = zz.x;
}
public Float4(Float xx){
x = xx.x;
y = xx.x;
z = xx.x;
w = xx.x;
}
public Float4(Float xx,Float yy,Float zz,Float ww){
x = xx.x;
y = yy.x;
z = zz.x;
w = ww.x;
}