public static Type DTypeToType(DType type)
{
Type temp = null;
if (!fundamentalTypes.TryGetValue(type, out temp))
temp = null;
return temp;
}
static DigitsArray()
{
unchecked
{
AllBits = (DType)~((DType)0);
HiBitSet = (DType)(((DType)1) << (DataSizeBits) - 1);
}
}
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
type = analyzer.ResolveTypeName(typeName, analyzer.CurrentType, analyzer.CurrentRoutine, position, false);
analyzer.AnalyzeConstructedType(type);
return new Evaluation(this);
}
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
access = info.Access;
this.typeRef.Analyze(analyzer);
this.type = this.typeRef.ResolvedTypeOrUnknown;
analyzer.AnalyzeConstructedType(type);
return new Evaluation(this);
}
//helper method, should not be used generally
public object ReadValue (DType dtype)
{
switch (dtype)
{
case DType.Byte:
return ReadByte ();
case DType.Boolean:
return ReadBoolean ();
case DType.Int16:
return ReadInt16 ();
case DType.UInt16:
return ReadUInt16 ();
case DType.Int32:
return ReadInt32 ();
case DType.UInt32:
return ReadUInt32 ();
case DType.Int64:
return ReadInt64 ();
case DType.UInt64:
return ReadUInt64 ();
#if !DISABLE_SINGLE
case DType.Single:
return ReadSingle ();
#endif
case DType.Double:
return ReadDouble ();
case DType.String:
return ReadString ();
case DType.ObjectPath:
return ReadObjectPath ();
case DType.Signature:
return ReadSignature ();
case DType.Variant:
return ReadVariant ();
default:
throw new Exception ("Unhandled D-Bus type: " + dtype);
}
}
public DVar[] Fields = new DVar[12]; //This is explicityly left unprotected to reduce access overhead
public DType SetType(DType type)
{
if (!DType.IsParentOf(type))
throw new Exception(string.Format("Type {0} is not a parent of tyoe {1} and so cannot be extended", DType, type));
DType = type;
var maxFieldIndex = DType.FieldIndex;
if (maxFieldIndex >= Fields.Length)
{
var newFields = new DVar[Fields.Length + 10];
Array.Copy(Fields, newFields, Fields.Length);
Fields = newFields;
}
return type;
}
public PropertyInvokeDialog(Window parent, Bus bus, string busName, ObjectPath path, IElement element)
: base(element.Name, parent, DialogFlags.DestroyWithParent | DialogFlags.Modal)
{
this.Build ();
this.parent = parent;
this.setAlign.HideAll ();
this.WidthRequest = 250;
this.HeightRequest = 150;
this.propertyName.Text = element.Name;
this.propertyType = Mapper.DTypeFromString (element.Data.ReturnType);
try {
this.caller = new PropertyCaller (bus, busName, path, element.Parent.Name, element.Name, element.Data);
} catch (Exception e) {
Logging.Error ("Error while creating the invocation proxy", e, parent);
buttonExecute.Sensitive = false;
}
}
public static int GetAlignment(DType dtype)
{
switch (dtype) {
case DType.Byte:
return 1;
case DType.Boolean:
return 4;
case DType.Int16:
case DType.UInt16:
return 2;
case DType.Int32:
case DType.UInt32:
return 4;
case DType.Int64:
case DType.UInt64:
return 8;
#if !DISABLE_SINGLE
case DType.Single: //Not yet supported!
return 4;
#endif
case DType.Double:
return 8;
case DType.String:
return 4;
case DType.ObjectPath:
return 4;
case DType.Signature:
return 1;
case DType.Array:
return 4;
case DType.Struct:
case DType.StructBegin:
return 8;
case DType.Variant:
return 1;
case DType.DictEntry:
case DType.DictEntryBegin:
return 8;
case DType.Invalid:
default:
throw new Exception ("Cannot determine alignment of " + dtype);
}
}
public static int GetAlignment (DType dtype)
{
switch (dtype) {
case DType.Byte:
return 1;
case DType.Boolean:
return 4;
case DType.Int16:
case DType.UInt16:
return 2;
case DType.Int32:
case DType.UInt32:
return 4;
case DType.Int64:
case DType.UInt64:
return 8;
#if !DISABLE_SINGLE
case DType.Single: //Not yet supported!
return 4;
#endif
case DType.Double:
return 8;
case DType.String:
return 4;
case DType.ObjectPath:
return 4;
case DType.Signature:
return 1;
case DType.Array:
return 4;
case DType.StructBegin:
return 8;
case DType.Variant:
return 1;
case DType.DictEntryBegin:
return 8;
case DType.UnixFileDescriptor:
return 4;//note that this refers to the length of the INDEX to the FD, not the FD itself
case DType.Invalid:
default:
throw new Exception ("Cannot determine alignment of " + dtype);
}
}
internal Signature(DType[] value)
{
if (value == null)
throw new ArgumentNullException ("value");
if (value.Length == 0) {
this.data = Empty.data;
return;
}
if (value.Length == 1) {
this.data = DataForDType (value[0]);
return;
}
this.data = new byte[value.Length];
for (int i = 0 ; i != value.Length ; i++)
this.data[i] = (byte)value[i];
}
public static object Convert(DType type, string value)
{
switch (type) {
case DType.Boolean:
return bool.Parse (value);
case DType.Byte:
return byte.Parse (value);
case DType.Int16:
return short.Parse (value);
case DType.Int32:
return int.Parse (value);
case DType.Int64:
return long.Parse (value);
case DType.UInt32:
return uint.Parse (value);
case DType.UInt64:
return ulong.Parse (value);
case DType.UInt16:
return ushort.Parse (value);
default:
return value;
}
}
public XArray LogNormal(Shape shape, double mean, double std_dev, DType dtype = DType.Float32)
{
return(NativeHelper.RandomLogNormal(shape, mean, std_dev, dtype));
}
public XArray FisherF(Shape shape, double m, double n, DType dtype = DType.Float32)
{
return(NativeHelper.RandomFisherF(shape, m, n, dtype));
}
internal Signature(DType value)
{
this.data = DataForDType(value);
}
public XArray Weibull(Shape shape, double a, double b, DType dtype = DType.Float32)
{
return(NativeHelper.RandomWeibull(shape, a, b, dtype));
}
public void EmitDirectTypeOf(DType/*!*/ dtype)
{
Debug.Assert(dtype != null);
il.Emit(OpCodes.Ldtoken, dtype.RealType);
il.Emit(OpCodes.Call, Methods.GetTypeFromHandle);
il.Emit(OpCodes.Call, Methods.ClrObject_WrapRealObject);
}
public DMemberRef(DMember/*!*/ member, DType/*!*/ type)
{
Debug.Assert(member != null && type != null);
this.member = member;
this.type = type;
}
public static XArray RandomChoice(Shape shape, int n, XArray weight, bool replace = true, DType dtype = DType.Float32)
{
XArray r = new XArray(shape, dtype);
NativeWrapper.TS_Random_ChoiceWithWeight(r.GetRef(), n, weight.GetRef(), replace);
return(r);
}
internal static int ShiftRight(DType[] buffer, int shiftCount)
{
int shiftAmount = DigitsArray.DataSizeBits;
int invShift = 0;
int bufLen = buffer.Length;
while (bufLen > 1 && buffer[bufLen - 1] == 0)
{
bufLen--;
}
for (int count = shiftCount; count > 0; count -= shiftAmount)
{
if (count < shiftAmount)
{
shiftAmount = count;
invShift = DigitsArray.DataSizeBits - shiftAmount;
}
ulong carry = 0;
for (int i = bufLen - 1; i >= 0; i--)
{
ulong val = ((ulong)buffer[i]) >> shiftAmount;
val |= carry;
carry = ((ulong)buffer[i]) << invShift;
buffer[i] = (DType)(val);
}
}
while (bufLen > 1 && buffer[bufLen - 1] == 0)
{
bufLen--;
}
return bufLen;
}
/// <summary>
/// Used by the compiler for unresolved properties.
/// </summary>
public UnknownProperty(DType/*!*/ declaringType, string/*!*/ name)
: base(name)
{
Debug.Assert(declaringType != null && name != null);
this.declaringType = declaringType;
}
public static XArray RandomLogNormal(Shape shape, double mean, double std_dev, DType dtype = DType.Float32)
{
XArray r = new XArray(shape, dtype);
NativeWrapper.TS_Random_LogNormal(r.GetRef(), mean, std_dev);
return(r);
}
internal override DMemberRef GetImplementationInSuperTypes(DType/*!*/ type, bool searchSupertypes, ref bool inSupertype)
{
while (type != null && !type.IsUnknown)
{
KnownProperty result = type.GetDeclaredProperty<KnownProperty>(this.Name);
if (result != null)
{
// private members are not visible from subtype:
if (result.IsPrivate && inSupertype) break;
return new DMemberRef(result, type);
}
if (!searchSupertypes) break;
inSupertype = true;
type = type.Base;
}
inSupertype = false;
return null;
}
internal override void ReportAbstractNotImplemented(ErrorSink/*!*/ errors, DType/*!*/ declaringType, PhpType/*!*/ referringType)
{
errors.Add(Errors.AbstractPropertyNotImplemented, referringType.Declaration.SourceUnit,
referringType.Declaration.Position, referringType.FullName, declaringType.MakeFullGenericName(), this.FullName);
ReportError(errors, Errors.RelatedLocation);
}
public override bool CheckInvocation(TexlNode[] args, DType[] argTypes, IErrorContainer errors, out DType returnType, out Dictionary <TexlNode, DType> nodeToCoercedTypeMap)
{
Contracts.AssertValue(args);
Contracts.AssertAllValues(args);
Contracts.AssertValue(argTypes);
Contracts.Assert(args.Length == argTypes.Length);
Contracts.AssertValue(errors);
Contracts.Assert(MinArity <= args.Length && args.Length <= MaxArity);
nodeToCoercedTypeMap = new Dictionary <TexlNode, DType>();
int count = args.Length;
// Check the args.
bool fArgsValid = true;
for (int i = 0; i < count; i++)
{
fArgsValid &= CheckType(args[i], argTypes[i], DType.Boolean, errors, out var matchedWithCoercion);
if (matchedWithCoercion)
{
CollectionUtils.Add(ref nodeToCoercedTypeMap, args[i], DType.Boolean);
}
}
returnType = ReturnType;
return(fArgsValid);
}
public XArray Choice(Shape shape, int n, bool replace = true, DType dtype = DType.Float32)
{
return(NativeHelper.RandomChoice(shape, n, replace, dtype));
}
/// <summary>
/// Randoms the bernoulli.
/// </summary>
/// <param name="seedSource">The seed source.</param>
/// <param name="p">The p.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="type">The type.</param>
/// <param name="sizes">The sizes.</param>
/// <returns>TVar.</returns>
public static Variable RandomBernoulli(SeedSource seedSource, ScalarVar p, IAllocator allocator, DType type, params long[] sizes)
{
return(new Variable(new FillExpression(allocator, type, sizes, res => Ops.RandomBernoulli(res, seedSource, p.Evaluate()))));
}
internal Signature (DType[] value)
{
this.data = new byte[value.Length];
/*
MemoryStream ms = new MemoryStream (this.data);
foreach (DType t in value)
ms.WriteByte ((byte)t);
*/
for (int i = 0 ; i != value.Length ; i++)
this.data[i] = (byte)value[i];
}
/// <summary>
/// Ases the type.
/// </summary>
/// <param name="elementType">Type of the element.</param>
/// <returns>TVar.</returns>
public Variable AsType(DType elementType)
{
return(new Variable(new AsTypeExpression(this.Expression, elementType)));
}
internal DigitsArray(DType[] copyFrom)
{
Allocate(copyFrom.Length);
CopyFrom(copyFrom, 0, 0, copyFrom.Length);
ResetDataUsed();
}
/// <summary>
/// Fills the specified value.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="type">The type.</param>
/// <param name="sizes">The sizes.</param>
/// <returns>TVar.</returns>
public static Variable Fill(ScalarVar value, IAllocator allocator, DType type, params long[] sizes)
{
return(new Variable(new FillExpression(allocator, type, sizes, res => Ops.Fill(res, value.Evaluate()))));
}
internal virtual DMemberRef GetImplementationInSuperTypes(DType/*!*/ type, bool searchSupertypes, ref bool inSupertype)
{
Debug.Fail("N/A");
throw null;
}
/// <summary>
/// Randoms the uniform.
/// </summary>
/// <param name="seedSource">The seed source.</param>
/// <param name="min">The minimum.</param>
/// <param name="max">The maximum.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="type">The type.</param>
/// <param name="sizes">The sizes.</param>
/// <returns>TVar.</returns>
public static Variable RandomUniform(SeedSource seedSource, ScalarVar min, ScalarVar max, IAllocator allocator, DType type, params long[] sizes)
{
return(new Variable(new FillExpression(allocator, type, sizes, res => Ops.RandomUniform(res, seedSource, min.Evaluate(), max.Evaluate()))));
}
public override int GetAttributeUsageCount(DType/*!*/ type, AST.CustomAttribute.TargetSelectors selector)
{
return attributes.Count(type, selector);
}
/// <summary>
/// Randoms the normal.
/// </summary>
/// <param name="seedSource">The seed source.</param>
/// <param name="mean">The mean.</param>
/// <param name="stdv">The STDV.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="type">The type.</param>
/// <param name="sizes">The sizes.</param>
/// <returns>TVar.</returns>
public static Variable RandomNormal(SeedSource seedSource, ScalarVar mean, ScalarVar stdv, IAllocator allocator, DType type, params long[] sizes)
{
return(new Variable(new FillExpression(allocator, type, sizes, res => Ops.RandomNormal(res, seedSource, mean.Evaluate(), stdv.Evaluate()))));
}
public XArray Gamma(Shape shape, double alpha, double beta, DType dtype = DType.Float32)
{
return(NativeHelper.RandomGamma(shape, alpha, beta, dtype));
}
/// <summary>
/// Randoms the exponential.
/// </summary>
/// <param name="seedSource">The seed source.</param>
/// <param name="lambda">The lambda.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="type">The type.</param>
/// <param name="sizes">The sizes.</param>
/// <returns>TVar.</returns>
public static Variable RandomExponential(SeedSource seedSource, ScalarVar lambda, IAllocator allocator, DType type, params long[] sizes)
{
return(new Variable(new FillExpression(allocator, type, sizes, res => Ops.RandomExponential(res, seedSource, lambda.Evaluate()))));
}
public XArray ExtremeValue(Shape shape, double a, double b, DType dtype = DType.Float32)
{
return(NativeHelper.RandomExtremeValue(shape, a, b, dtype));
}
/// <summary>
/// Randoms the cauchy.
/// </summary>
/// <param name="seedSource">The seed source.</param>
/// <param name="median">The median.</param>
/// <param name="sigma">The sigma.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="type">The type.</param>
/// <param name="sizes">The sizes.</param>
/// <returns>TVar.</returns>
public static Variable RandomCauchy(SeedSource seedSource, ScalarVar median, ScalarVar sigma, IAllocator allocator, DType type, params long[] sizes)
{
return(new Variable(new FillExpression(allocator, type, sizes, res => Ops.RandomCauchy(res, seedSource, median.Evaluate(), sigma.Evaluate()))));
}
public XArray Cauchy(Shape shape, double a, double b, DType dtype = DType.Float32)
{
return(NativeHelper.RandomCauchy(shape, a, b, dtype));
}
public XArray Shuffle(Shape shape, DType dtype = DType.Float32)
{
return(NativeHelper.RandomShuffle(shape, dtype));
}
public XArray StudentT(Shape shape, double n, DType dtype = DType.Float32)
{
return(NativeHelper.RandomStudentT(shape, n, dtype));
}
public XArray Permutation(Shape shape, DType dtype = DType.Float32)
{
return(NativeHelper.RandomPermutation(shape, dtype));
}
internal override void ResolveName(Analyzer/*!*/ analyzer)
{
this.typeRef.Analyze(analyzer);
this.type = this.typeRef.ResolvedTypeOrUnknown;
// analyze constructed type (we are in the full analysis):
analyzer.AnalyzeConstructedType(type);
constant = analyzer.ResolveClassConstantName(type, name, position, analyzer.CurrentType, analyzer.CurrentRoutine,
out runtimeVisibilityCheck);
}
public XArray Rand(Shape shape, DType dtype = DType.Float32)
{
return(Uniform(shape, 0, 1, dtype));
}
//this will become obsolete soon
internal Signature (DType value)
{
this.data = new byte[] {(byte)value};
}
internal void CopyFrom(DType[] source, int sourceOffset, int offset, int length)
{
Array.Copy(source, sourceOffset, m_data, 0, length);
}
internal static int ShiftLeft(DType[] buffer, int shiftCount)
{
int shiftAmount = DigitsArray.DataSizeBits;
int bufLen = buffer.Length;
while (bufLen > 1 && buffer[bufLen - 1] == 0)
{
bufLen--;
}
for (int count = shiftCount; count > 0; count -= shiftAmount)
{
if (count < shiftAmount)
{
shiftAmount = count;
}
ulong carry = 0;
for (int i = 0; i < bufLen; i++)
{
ulong val = ((ulong)buffer[i]) << shiftAmount;
val |= carry;
buffer[i] = (DType)(val & DigitsArray.AllBits);
carry = (val >> DigitsArray.DataSizeBits);
}
if (carry != 0)
{
if (bufLen + 1 <= buffer.Length)
{
buffer[bufLen] = (DType)carry;
bufLen++;
carry = 0;
}
else
{
throw new OverflowException();
}
}
}
return bufLen;
}
private static void MultiDivide(BigInteger leftSide, BigInteger rightSide, out BigInteger quotient, out BigInteger remainder)
{
if (rightSide.IsZero)
{
throw new DivideByZeroException();
}
DType val = rightSide.m_digits[rightSide.m_digits.DataUsed - 1];
int d = 0;
for (uint mask = DigitsArray.HiBitSet; mask != 0 && (val & mask) == 0; mask >>= 1)
{
d++;
}
int remainderLen = leftSide.m_digits.DataUsed + 1;
DType[] remainderDat = new DType[remainderLen];
leftSide.m_digits.CopyTo(remainderDat, 0, leftSide.m_digits.DataUsed);
DigitsArray.ShiftLeft(remainderDat, d);
rightSide = rightSide << d;
ulong firstDivisor = rightSide.m_digits[rightSide.m_digits.DataUsed - 1];
ulong secondDivisor = (rightSide.m_digits.DataUsed < 2 ? (DType)0 : rightSide.m_digits[rightSide.m_digits.DataUsed - 2]);
int divisorLen = rightSide.m_digits.DataUsed + 1;
DigitsArray dividendPart = new DigitsArray(divisorLen, divisorLen);
DType[] result = new DType[leftSide.m_digits.Count + 1];
int resultPos = 0;
ulong carryBit = (ulong)0x1 << DigitsArray.DataSizeBits; // 0x100000000
for (int j = remainderLen - rightSide.m_digits.DataUsed, pos = remainderLen - 1; j > 0; j--, pos--)
{
ulong dividend = ((ulong)remainderDat[pos] << DigitsArray.DataSizeBits) + (ulong)remainderDat[pos - 1];
ulong qHat = (dividend / firstDivisor);
ulong rHat = (dividend % firstDivisor);
while (pos >= 2)
{
if (qHat == carryBit || (qHat * secondDivisor) > ((rHat << DigitsArray.DataSizeBits) + remainderDat[pos - 2]))
{
qHat--;
rHat += firstDivisor;
if (rHat < carryBit)
{
continue;
}
}
break;
}
for (int h = 0; h < divisorLen; h++)
{
dividendPart[divisorLen - h - 1] = remainderDat[pos - h];
}
BigInteger dTemp = new BigInteger(dividendPart);
BigInteger rTemp = rightSide * (long)qHat;
while (rTemp > dTemp)
{
qHat--;
rTemp -= rightSide;
}
rTemp = dTemp - rTemp;
for (int h = 0; h < divisorLen; h++)
{
remainderDat[pos - h] = rTemp.m_digits[rightSide.m_digits.DataUsed - h];
}
result[resultPos++] = (DType)qHat;
}
Array.Reverse(result, 0, resultPos);
quotient = new BigInteger(new DigitsArray(result));
int n = DigitsArray.ShiftRight(remainderDat, d);
DigitsArray rDA = new DigitsArray(n, n);
rDA.CopyFrom(remainderDat, 0, 0, rDA.DataUsed);
remainder = new BigInteger(rDA);
}
public XArray RandInt(Shape shape, double low = 0, double high = 1, DType dtype = DType.Float32)
{
return(NativeHelper.RandomRandInt(shape, low, high, dtype));
}
public Type ToType(ref int pos)
{
// TODO: Find a way to avoid these null checks everywhere.
if (data == null)
{
return(typeof(void));
}
DType dtype = (DType)data[pos++];
switch (dtype)
{
case DType.Invalid:
return(typeof(void));
case DType.Byte:
return(typeof(byte));
case DType.Boolean:
return(typeof(bool));
case DType.Int16:
return(typeof(short));
case DType.UInt16:
return(typeof(ushort));
case DType.Int32:
return(typeof(int));
case DType.UInt32:
return(typeof(uint));
case DType.Int64:
return(typeof(long));
case DType.UInt64:
return(typeof(ulong));
case DType.Single: ////not supported by libdbus at time of writing
return(typeof(float));
case DType.Double:
return(typeof(double));
case DType.String:
return(typeof(string));
case DType.ObjectPath:
return(typeof(ObjectPath));
case DType.Signature:
return(typeof(Signature));
case DType.Array:
//peek to see if this is in fact a dictionary
if ((DType)data[pos] == DType.DictEntryBegin)
{
//skip over the {
pos++;
Type keyType = ToType(ref pos);
Type valueType = ToType(ref pos);
//skip over the }
pos++;
return(typeof(Dictionary <,>).MakeGenericType(new [] { keyType, valueType }));
}
else
{
return(ToType(ref pos).MakeArrayType());
}
case DType.StructBegin:
List <Type> innerTypes = new List <Type> ();
while (((DType)data[pos]) != DType.StructEnd)
{
innerTypes.Add(ToType(ref pos));
}
// go over the struct end
pos++;
return(DBusStruct.FromInnerTypes(innerTypes.ToArray()));
case DType.DictEntryBegin:
return(typeof(System.Collections.Generic.KeyValuePair <,>));
case DType.Variant:
return(typeof(object));
default:
throw new NotSupportedException("Parsing or converting this signature is not yet supported (signature was '" + this + "'), at DType." + dtype);
}
}
internal void CopyTo(DType[] array, int offset, int length)
{
Array.Copy(m_data, 0, array, offset, length);
}
public XArray Geometric(Shape shape, double prob, DType dtype = DType.Int32)
{
return(NativeHelper.RandomGeometric(shape, prob, dtype));
}
private static void SingleDivide(BigInteger leftSide, BigInteger rightSide, out BigInteger quotient, out BigInteger remainder)
{
if (rightSide.IsZero)
{
throw new DivideByZeroException();
}
DigitsArray remainderDigits = new DigitsArray(leftSide.m_digits);
remainderDigits.ResetDataUsed();
int pos = remainderDigits.DataUsed - 1;
ulong divisor = (ulong)rightSide.m_digits[0];
ulong dividend = (ulong)remainderDigits[pos];
DType[] result = new DType[leftSide.m_digits.Count];
leftSide.m_digits.CopyTo(result, 0, result.Length);
int resultPos = 0;
if (dividend >= divisor)
{
result[resultPos++] = (DType)(dividend / divisor);
remainderDigits[pos] = (DType)(dividend % divisor);
}
pos--;
while (pos >= 0)
{
dividend = ((ulong)(remainderDigits[pos + 1]) << DigitsArray.DataSizeBits) + (ulong)remainderDigits[pos];
result[resultPos++] = (DType)(dividend / divisor);
remainderDigits[pos + 1] = 0;
remainderDigits[pos--] = (DType)(dividend % divisor);
}
remainder = new BigInteger(remainderDigits);
DigitsArray quotientDigits = new DigitsArray(resultPos + 1, resultPos);
int j = 0;
for (int i = quotientDigits.DataUsed - 1; i >= 0; i--, j++)
{
quotientDigits[j] = result[i];
}
quotient = new BigInteger(quotientDigits);
}
public XArray NegativeBinomial(Shape shape, int k, double prob, DType dtype = DType.Float32)
{
return(NativeHelper.RandomNegativeBinomial(shape, k, prob, dtype));
}
internal virtual void ReportMethodNotCompatible(ErrorSink/*!*/ errors, DType/*!*/ declaringType, PhpType/*!*/ referringType)
{
// to be implemented by methods and properties
Debug.Fail();
throw null;
}
public XArray Poisson(Shape shape, double rate, DType dtype = DType.Float32)
{
return(NativeHelper.RandomPoisson(shape, rate, dtype));
}
internal override Evaluation Analyze(Analyzer/*!*/ analyzer, ExInfoFromParent info)
{
base.Analyze(analyzer, info);
this.typeRef.Analyze(analyzer);
this.type = this.typeRef.ResolvedTypeOrUnknown;
// analyze constructed type (new constructed type cane be used here):
analyzer.AnalyzeConstructedType(type);
if (type.TypeDesc.Equals(DTypeDesc.InterlockedTypeDesc))
analyzer.ErrorSink.Add(Warnings.ClassBehaviorMayBeUnexpected, analyzer.SourceUnit, position, type.FullName);
return new Evaluation(this);
}
public XArray Exponential(Shape shape, double rate, DType dtype = DType.Float32)
{
return(NativeHelper.RandomExponential(shape, rate, dtype));
}
public XArray Binomial(Shape shape, int trials, double prob, DType dtype = DType.Float32)
{
return(NativeHelper.RandomBinomial(shape, trials, prob, dtype));
}
public static Signature GetSig(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
//this is inelegant, but works for now
if (type == typeof(Signature))
{
return(Signature.SignatureSig);
}
if (type == typeof(ObjectPath))
{
return(Signature.ObjectPathSig);
}
if (type == typeof(void))
{
return(Signature.Empty);
}
if (type == typeof(string))
{
return(Signature.StringSig);
}
if (type == typeof(object))
{
return(Signature.VariantSig);
}
if (type.IsArray)
{
return(MakeArray(GetSig(type.GetElementType())));
}
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(IDictionary <,>) || type.GetGenericTypeDefinition() == typeof(Dictionary <,>)))
{
Type[] genArgs = type.GetGenericArguments();
return(Signature.MakeDict(GetSig(genArgs[0]), GetSig(genArgs[1])));
}
if (Mapper.IsPublic(type))
{
return(Signature.ObjectPathSig);
}
if (!type.IsPrimitive && !type.IsEnum)
{
Signature sig = Signature.Empty;
foreach (FieldInfo fi in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
sig += GetSig(fi.FieldType);
}
return(Signature.MakeStruct(sig));
}
DType dtype = Signature.TypeToDType(type);
return(new Signature(dtype));
}