Range Type

Assembly: Hedgehog.dll

Base Type: obj

Static members

Static member	Description
`Range.Constant(x, y)` Full Usage: `Range.Constant(x, y)` Parameters: x : `'T` y : `'T` Returns: `Range<'T>`	Construct a range which is unaffected by the size parameter. x : `'T` y : `'T` Returns: `Range<'T>`
`Range.Constant(z, x, y)` Full Usage: `Range.Constant(z, x, y)` Parameters: z : `'T` x : `'T` y : `'T` Returns: `Range<'T>`	Construct a range which is unaffected by the size parameter with a origin point which may differ from the bounds. z : `'T` x : `'T` y : `'T` Returns: `Range<'T>`
`Range.ConstantBoundedByte()` Full Usage: `Range.ConstantBoundedByte()` Returns: `Range<byte>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<byte>`
`Range.ConstantBoundedDecimal()` Full Usage: `Range.ConstantBoundedDecimal()` Returns: `Range<decimal>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<decimal>`
`Range.ConstantBoundedDouble()` Full Usage: `Range.ConstantBoundedDouble()` Returns: `Range<double>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<double>`
`Range.ConstantBoundedInt16()` Full Usage: `Range.ConstantBoundedInt16()` Returns: `Range<int16>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<int16>`
`Range.ConstantBoundedInt32()` Full Usage: `Range.ConstantBoundedInt32()` Returns: `Range<int32>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<int32>`
`Range.ConstantBoundedInt64()` Full Usage: `Range.ConstantBoundedInt64()` Returns: `Range<int64>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<int64>`
`Range.ConstantBoundedSByte()` Full Usage: `Range.ConstantBoundedSByte()` Returns: `Range<sbyte>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<sbyte>`
`Range.ConstantBoundedSingle()` Full Usage: `Range.ConstantBoundedSingle()` Returns: `Range<single>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<single>`
`Range.ConstantBoundedUInt16()` Full Usage: `Range.ConstantBoundedUInt16()` Returns: `Range<uint16>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<uint16>`
`Range.ConstantBoundedUInt32()` Full Usage: `Range.ConstantBoundedUInt32()` Returns: `Range<uint32>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<uint32>`
`Range.ConstantBoundedUInt64()` Full Usage: `Range.ConstantBoundedUInt64()` Returns: `Range<uint64>`	Construct a range which is unaffected by the size parameter using the full range of a data type. Returns: `Range<uint64>`
`Range.ExponentialBoundedByte()` Full Usage: `Range.ExponentialBoundedByte()` Returns: `Range<byte>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<byte>`
`Range.ExponentialBoundedDecimal()` Full Usage: `Range.ExponentialBoundedDecimal()` Returns: `Range<decimal>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<decimal>`
`Range.ExponentialBoundedDouble()` Full Usage: `Range.ExponentialBoundedDouble()` Returns: `Range<double>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<double>`
`Range.ExponentialBoundedInt16()` Full Usage: `Range.ExponentialBoundedInt16()` Returns: `Range<int16>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<int16>`
`Range.ExponentialBoundedInt32()` Full Usage: `Range.ExponentialBoundedInt32()` Returns: `Range<int32>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<int32>`
`Range.ExponentialBoundedInt64()` Full Usage: `Range.ExponentialBoundedInt64()` Returns: `Range<int64>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<int64>`
`Range.ExponentialBoundedSByte()` Full Usage: `Range.ExponentialBoundedSByte()` Returns: `Range<sbyte>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<sbyte>`
`Range.ExponentialBoundedSingle()` Full Usage: `Range.ExponentialBoundedSingle()` Returns: `Range<single>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<single>`
`Range.ExponentialBoundedUInt16()` Full Usage: `Range.ExponentialBoundedUInt16()` Returns: `Range<uint16>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<uint16>`
`Range.ExponentialBoundedUInt32()` Full Usage: `Range.ExponentialBoundedUInt32()` Returns: `Range<uint32>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<uint32>`
`Range.ExponentialBoundedUInt64()` Full Usage: `Range.ExponentialBoundedUInt64()` Returns: `Range<uint64>`	Construct a range which is scaled exponentially relative to the size parameter and uses the full range of a data type. Returns: `Range<uint64>`
`Range.ExponentialByte(x, y)` Full Usage: `Range.ExponentialByte(x, y)` Parameters: x : `byte` y : `byte` Returns: `Range<byte>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `byte` y : `byte` Returns: `Range<byte>`
`Range.ExponentialDecimal(x, y)` Full Usage: `Range.ExponentialDecimal(x, y)` Parameters: x : `decimal` y : `decimal` Returns: `Range<decimal>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `decimal` y : `decimal` Returns: `Range<decimal>`
`Range.ExponentialDouble(x, y)` Full Usage: `Range.ExponentialDouble(x, y)` Parameters: x : `double` y : `double` Returns: `Range<double>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `double` y : `double` Returns: `Range<double>`
`Range.ExponentialFromByte(z, x, y)` Full Usage: `Range.ExponentialFromByte(z, x, y)` Parameters: z : `byte` x : `byte` y : `byte` Returns: `Range<byte>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `byte` x : `byte` y : `byte` Returns: `Range<byte>`
`Range.ExponentialFromDecimal(z, x, y)` Full Usage: `Range.ExponentialFromDecimal(z, x, y)` Parameters: z : `decimal` x : `decimal` y : `decimal` Returns: `Range<decimal>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `decimal` x : `decimal` y : `decimal` Returns: `Range<decimal>`
`Range.ExponentialFromDouble(z, x, y)` Full Usage: `Range.ExponentialFromDouble(z, x, y)` Parameters: z : `double` x : `double` y : `double` Returns: `Range<double>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `double` x : `double` y : `double` Returns: `Range<double>`
`Range.ExponentialFromInt16(z, x, y)` Full Usage: `Range.ExponentialFromInt16(z, x, y)` Parameters: z : `int16` x : `int16` y : `int16` Returns: `Range<int16>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `int16` x : `int16` y : `int16` Returns: `Range<int16>`
`Range.ExponentialFromInt32(z, x, y)` Full Usage: `Range.ExponentialFromInt32(z, x, y)` Parameters: z : `int32` x : `int32` y : `int32` Returns: `Range<int32>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `int32` x : `int32` y : `int32` Returns: `Range<int32>`
`Range.ExponentialFromInt64(z, x, y)` Full Usage: `Range.ExponentialFromInt64(z, x, y)` Parameters: z : `int64` x : `int64` y : `int64` Returns: `Range<int64>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `int64` x : `int64` y : `int64` Returns: `Range<int64>`
`Range.ExponentialFromSByte(z, x, y)` Full Usage: `Range.ExponentialFromSByte(z, x, y)` Parameters: z : `sbyte` x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `sbyte` x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`
`Range.ExponentialFromSingle(z, x, y)` Full Usage: `Range.ExponentialFromSingle(z, x, y)` Parameters: z : `single` x : `single` y : `single` Returns: `Range<single>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `single` x : `single` y : `single` Returns: `Range<single>`
`Range.ExponentialFromUInt16(z, x, y)` Full Usage: `Range.ExponentialFromUInt16(z, x, y)` Parameters: z : `uint16` x : `uint16` y : `uint16` Returns: `Range<uint16>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `uint16` x : `uint16` y : `uint16` Returns: `Range<uint16>`
`Range.ExponentialFromUInt32(z, x, y)` Full Usage: `Range.ExponentialFromUInt32(z, x, y)` Parameters: z : `uint32` x : `uint32` y : `uint32` Returns: `Range<uint32>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `uint32` x : `uint32` y : `uint32` Returns: `Range<uint32>`
`Range.ExponentialFromUInt64(z, x, y)` Full Usage: `Range.ExponentialFromUInt64(z, x, y)` Parameters: z : `uint64` x : `uint64` y : `uint64` Returns: `Range<uint64>`	Construct a range which scales the bounds exponentially relative to the size parameter. z : `uint64` x : `uint64` y : `uint64` Returns: `Range<uint64>`
`Range.ExponentialInt16(x, y)` Full Usage: `Range.ExponentialInt16(x, y)` Parameters: x : `int16` y : `int16` Returns: `Range<int16>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `int16` y : `int16` Returns: `Range<int16>`
`Range.ExponentialInt32(x, y)` Full Usage: `Range.ExponentialInt32(x, y)` Parameters: x : `int32` y : `int32` Returns: `Range<int32>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `int32` y : `int32` Returns: `Range<int32>`
`Range.ExponentialInt64(x, y)` Full Usage: `Range.ExponentialInt64(x, y)` Parameters: x : `int64` y : `int64` Returns: `Range<int64>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `int64` y : `int64` Returns: `Range<int64>`
`Range.ExponentialSByte(x, y)` Full Usage: `Range.ExponentialSByte(x, y)` Parameters: x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`
`Range.ExponentialSingle(x, y)` Full Usage: `Range.ExponentialSingle(x, y)` Parameters: x : `single` y : `single` Returns: `Range<single>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `single` y : `single` Returns: `Range<single>`
`Range.ExponentialUInt16(x, y)` Full Usage: `Range.ExponentialUInt16(x, y)` Parameters: x : `uint16` y : `uint16` Returns: `Range<uint16>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `uint16` y : `uint16` Returns: `Range<uint16>`
`Range.ExponentialUInt32(x, y)` Full Usage: `Range.ExponentialUInt32(x, y)` Parameters: x : `uint32` y : `uint32` Returns: `Range<uint32>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `uint32` y : `uint32` Returns: `Range<uint32>`
`Range.ExponentialUInt64(x, y)` Full Usage: `Range.ExponentialUInt64(x, y)` Parameters: x : `uint64` y : `uint64` Returns: `Range<uint64>`	Construct a range which scales the second bound exponentially relative to the size parameter. x : `uint64` y : `uint64` Returns: `Range<uint64>`
`Range.FromValue(value)` Full Usage: `Range.FromValue(value)` Parameters: value : `'T` Returns: `Range<'T>`	Construct a range which represents a constant single value. value : `'T` Returns: `Range<'T>`
`Range.LinearBoundedByte()` Full Usage: `Range.LinearBoundedByte()` Returns: `Range<byte>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<byte>`
`Range.LinearBoundedDecimal()` Full Usage: `Range.LinearBoundedDecimal()` Returns: `Range<decimal>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<decimal>`
`Range.LinearBoundedDouble()` Full Usage: `Range.LinearBoundedDouble()` Returns: `Range<double>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<double>`
`Range.LinearBoundedInt16()` Full Usage: `Range.LinearBoundedInt16()` Returns: `Range<int16>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<int16>`
`Range.LinearBoundedInt32()` Full Usage: `Range.LinearBoundedInt32()` Returns: `Range<int32>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<int32>`
`Range.LinearBoundedInt64()` Full Usage: `Range.LinearBoundedInt64()` Returns: `Range<int64>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<int64>`
`Range.LinearBoundedSByte()` Full Usage: `Range.LinearBoundedSByte()` Returns: `Range<sbyte>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<sbyte>`
`Range.LinearBoundedSingle()` Full Usage: `Range.LinearBoundedSingle()` Returns: `Range<single>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<single>`
`Range.LinearBoundedUInt16()` Full Usage: `Range.LinearBoundedUInt16()` Returns: `Range<uint16>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<uint16>`
`Range.LinearBoundedUInt32()` Full Usage: `Range.LinearBoundedUInt32()` Returns: `Range<uint32>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<uint32>`
`Range.LinearBoundedUInt64()` Full Usage: `Range.LinearBoundedUInt64()` Returns: `Range<uint64>`	Construct a range which is scaled relative to the size parameter and uses the full range of a data type. Returns: `Range<uint64>`
`Range.LinearByte(x, y)` Full Usage: `Range.LinearByte(x, y)` Parameters: x : `byte` y : `byte` Returns: `Range<byte>`	Construct a range which scales the second bound relative to the size parameter. x : `byte` y : `byte` Returns: `Range<byte>`
`Range.LinearDecimal(x, y)` Full Usage: `Range.LinearDecimal(x, y)` Parameters: x : `decimal` y : `decimal` Returns: `Range<decimal>`	Construct a range which scales the second bound relative to the size parameter. x : `decimal` y : `decimal` Returns: `Range<decimal>`
`Range.LinearDouble(x, y)` Full Usage: `Range.LinearDouble(x, y)` Parameters: x : `double` y : `double` Returns: `Range<double>`	Construct a range which scales the second bound relative to the size parameter. x : `double` y : `double` Returns: `Range<double>`
`Range.LinearFromByte(z, x, y)` Full Usage: `Range.LinearFromByte(z, x, y)` Parameters: z : `byte` x : `byte` y : `byte` Returns: `Range<byte>`	Construct a range which scales the bounds relative to the size parameter. z : `byte` x : `byte` y : `byte` Returns: `Range<byte>`
`Range.LinearFromDecimal(z, x, y)` Full Usage: `Range.LinearFromDecimal(z, x, y)` Parameters: z : `decimal` x : `decimal` y : `decimal` Returns: `Range<decimal>`	Construct a range which scales the bounds relative to the size parameter. z : `decimal` x : `decimal` y : `decimal` Returns: `Range<decimal>`
`Range.LinearFromDouble(z, x, y)` Full Usage: `Range.LinearFromDouble(z, x, y)` Parameters: z : `double` x : `double` y : `double` Returns: `Range<double>`	Construct a range which scales the bounds relative to the size parameter. z : `double` x : `double` y : `double` Returns: `Range<double>`
`Range.LinearFromInt16(z, x, y)` Full Usage: `Range.LinearFromInt16(z, x, y)` Parameters: z : `int16` x : `int16` y : `int16` Returns: `Range<int16>`	Construct a range which scales the bounds relative to the size parameter. z : `int16` x : `int16` y : `int16` Returns: `Range<int16>`
`Range.LinearFromInt32(z, x, y)` Full Usage: `Range.LinearFromInt32(z, x, y)` Parameters: z : `int32` x : `int32` y : `int32` Returns: `Range<int32>`	Construct a range which scales the bounds relative to the size parameter. z : `int32` x : `int32` y : `int32` Returns: `Range<int32>`
`Range.LinearFromInt64(z, x, y)` Full Usage: `Range.LinearFromInt64(z, x, y)` Parameters: z : `int64` x : `int64` y : `int64` Returns: `Range<int64>`	Construct a range which scales the bounds relative to the size parameter. z : `int64` x : `int64` y : `int64` Returns: `Range<int64>`
`Range.LinearFromSByte(z, x, y)` Full Usage: `Range.LinearFromSByte(z, x, y)` Parameters: z : `sbyte` x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`	Construct a range which scales the bounds relative to the size parameter. z : `sbyte` x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`
`Range.LinearFromSingle(z, x, y)` Full Usage: `Range.LinearFromSingle(z, x, y)` Parameters: z : `single` x : `single` y : `single` Returns: `Range<single>`	Construct a range which scales the bounds relative to the size parameter. z : `single` x : `single` y : `single` Returns: `Range<single>`
`Range.LinearFromUInt16(z, x, y)` Full Usage: `Range.LinearFromUInt16(z, x, y)` Parameters: z : `uint16` x : `uint16` y : `uint16` Returns: `Range<uint16>`	Construct a range which scales the bounds relative to the size parameter. z : `uint16` x : `uint16` y : `uint16` Returns: `Range<uint16>`
`Range.LinearFromUInt32(z, x, y)` Full Usage: `Range.LinearFromUInt32(z, x, y)` Parameters: z : `uint32` x : `uint32` y : `uint32` Returns: `Range<uint32>`	Construct a range which scales the bounds relative to the size parameter. z : `uint32` x : `uint32` y : `uint32` Returns: `Range<uint32>`
`Range.LinearFromUInt64(z, x, y)` Full Usage: `Range.LinearFromUInt64(z, x, y)` Parameters: z : `uint64` x : `uint64` y : `uint64` Returns: `Range<uint64>`	Construct a range which scales the bounds relative to the size parameter. z : `uint64` x : `uint64` y : `uint64` Returns: `Range<uint64>`
`Range.LinearInt16(x, y)` Full Usage: `Range.LinearInt16(x, y)` Parameters: x : `int16` y : `int16` Returns: `Range<int16>`	Construct a range which scales the second bound relative to the size parameter. x : `int16` y : `int16` Returns: `Range<int16>`
`Range.LinearInt32(x, y)` Full Usage: `Range.LinearInt32(x, y)` Parameters: x : `int32` y : `int32` Returns: `Range<int32>`	Construct a range which scales the second bound relative to the size parameter. x : `int32` y : `int32` Returns: `Range<int32>`
`Range.LinearInt64(x, y)` Full Usage: `Range.LinearInt64(x, y)` Parameters: x : `int64` y : `int64` Returns: `Range<int64>`	Construct a range which scales the second bound relative to the size parameter. x : `int64` y : `int64` Returns: `Range<int64>`
`Range.LinearSByte(x, y)` Full Usage: `Range.LinearSByte(x, y)` Parameters: x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`	Construct a range which scales the second bound relative to the size parameter. x : `sbyte` y : `sbyte` Returns: `Range<sbyte>`
`Range.LinearSingle(x, y)` Full Usage: `Range.LinearSingle(x, y)` Parameters: x : `single` y : `single` Returns: `Range<single>`	Construct a range which scales the second bound relative to the size parameter. x : `single` y : `single` Returns: `Range<single>`
`Range.LinearUInt16(x, y)` Full Usage: `Range.LinearUInt16(x, y)` Parameters: x : `uint16` y : `uint16` Returns: `Range<uint16>`	Construct a range which scales the second bound relative to the size parameter. x : `uint16` y : `uint16` Returns: `Range<uint16>`
`Range.LinearUInt32(x, y)` Full Usage: `Range.LinearUInt32(x, y)` Parameters: x : `uint32` y : `uint32` Returns: `Range<uint32>`	Construct a range which scales the second bound relative to the size parameter. x : `uint32` y : `uint32` Returns: `Range<uint32>`
`Range.LinearUInt64(x, y)` Full Usage: `Range.LinearUInt64(x, y)` Parameters: x : `uint64` y : `uint64` Returns: `Range<uint64>`	Construct a range which scales the second bound relative to the size parameter. x : `uint64` y : `uint64` Returns: `Range<uint64>`