Class VariableArray<T>

One-dimensional flat variable array.

Inheritance

Object

Variable

Variable<T[]>

VariableArrayBase<Variable<T>, T[]>

VariableArray<Variable<T>, T[]>

VariableArray<T>

Implements

CanGetContainers

IModelExpression<T[]>

SettableTo<Variable<T[]>>

ICloneable

HasItemVariables

IVariableJaggedArray

SettableTo<VariableArray<Variable<T>, T[]>>

IVariableArray<T>

IJaggedVariableArray<Variable<T>>

SettableTo<VariableArray<T>>

IVariableArray

IVariable

IModelExpression

HasObservedValue

Inherited Members

VariableArray<Variable<T>, T[]>.Range

VariableArray<Variable<T>, T[]>.Item[Range]

VariableArray<Variable<T>, T[]>.Item[Variable<Int32>]

VariableArray<Variable<T>, T[]>.Item[Int32]

VariableArray<Variable<T>, T[]>.IJaggedVariableArray<Variable<T>>.Item[IModelExpression]

VariableArray<Variable<T>, T[]>.Named(String)

VariableArray<Variable<T>, T[]>.Attrib(ICompilerAttribute)

VariableArray<Variable<T>, T[]>.Attrib(QueryType)

VariableArray<Variable<T>, T[]>.SetTo(VariableArray<Variable<T>, T[]>)

VariableArray<Variable<T>, T[]>.Clone()

VariableArray<Variable<T>, T[]>.IVariableArray.ReplaceRanges(Dictionary<Range, Range>, Dictionary<IModelExpression, IModelExpression>, Boolean)

VariableArrayBase<Variable<T>, T[]>.Ranges

VariableArrayBase<Variable<T>, T[]>.itemPrototype

VariableArrayBase<Variable<T>, T[]>.IVariableJaggedArray.ItemPrototype

VariableArrayBase<Variable<T>, T[]>.Item[IModelExpression[]]

VariableArrayBase<Variable<T>, T[]>.Item[Range[]]

VariableArrayBase<Variable<T>, T[]>.SetTo(VariableArrayBase<Variable<T>, T[]>)

VariableArrayBase<Variable<T>, T[]>.HasItemVariables.GetItemsUntyped()

Variable<T[]>.isReadOnly

Variable<T[]>.IsReadOnly

Variable<T[]>.observedValue

Variable<T[]>.HasObservedValue.ObservedValue

Variable<T[]>.ObservedValue

Variable<T[]>.ClearObservedValue()

Variable<T[]>.Clone()

Variable<T[]>.SetTo(Variable<T[]>)

Variable<T[]>.declaration

Variable<T[]>.Name

Variable<T[]>.IModelExpression.Name

Variable<T[]>.Named(String)

Variable<T[]>.Attrib(ICompilerAttribute)

Variable<T[]>.Attrib(QueryType)

Variable<T[]>.InitialiseTo<TDist>(TDist)

Variable<T[]>.InitialiseTo<TDist>(Variable<TDist>)

Variable<T[]>.InitialiseTo<TDist>(IModelExpression<TDist>)

Variable<T[]>.InitialiseBackwardTo<TDist>(TDist)

Variable<T[]>.InitialiseBackwardTo<TDist>(Variable<TDist>)

Variable<T[]>.InitialiseBackwardTo<TDist>(IModelExpression<TDist>)

Variable<T[]>.SetMarginalPrototype<TDist>(IModelExpression<TDist>)

Variable<T[]>.ForEach(Range)

Variable<T[]>.ForEach(Range[])

Variable<T[]>.Array(Range)

Variable<T[]>.Random<TDist>(Variable<TDist>)

Variable<T[]>.Factor(Func<T[]>)

Variable<T[]>.Factor<T1>(Func<T1, T[]>, Variable<T1>)

Variable<T[]>.Factor<T1>(Func<T1, T[]>, T1)

Variable<T[]>.Factor<T1, T2>(Func<T1, T2, T[]>, Variable<T1>, Variable<T2>)

Variable<T[]>.Factor<T1, T2>(FuncOut<T1, T2, T[]>, Variable<T1>, Variable<T2>)

Variable<T[]>.Factor<T1, T2>(Func<T1, T2, T[]>, T1, Variable<T2>)

Variable<T[]>.Factor<T1, T2>(Func<T1, T2, T[]>, Variable<T1>, T2)

Variable<T[]>.Factor<T1, T2>(Func<T1, T2, T[]>, T1, T2)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, Variable<T1>, Variable<T2>, Variable<T3>)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, T1, Variable<T2>, Variable<T3>)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, T1, T2, Variable<T3>)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, T1, Variable<T2>, T3)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, Variable<T1>, T2, Variable<T3>)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, Variable<T1>, Variable<T2>, T3)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, Variable<T1>, T2, T3)

Variable<T[]>.Factor<T1, T2, T3>(Func<T1, T2, T3, T[]>, T1, T2, T3)

Variable<T[]>.Factor<T1, T2, T3, T4>(Func<T1, T2, T3, T4, T[]>, Variable<T1>, Variable<T2>, Variable<T3>, Variable<T4>)

Variable<T[]>.FactorUntyped(MethodInfo, Variable[])

Variable<T[]>.OperatorUntyped(Variable.Operator, MethodInfo, Variable[])

Variable<T[]>.GreaterThan(Variable<T[]>, Variable<T[]>)

Variable<T[]>.GreaterThanOrEqual(Variable<T[]>, Variable<T[]>)

Variable.NameInGeneratedCode

Variable.IModelExpression.Name

Variable.Name

Variable.ToString()

Variable.Definition

Variable.IsDefined

Variable.IsDefinedInContext(List<ConditionBlock>)

Variable.IsPrefixOf<T>(IReadOnlyList<T>, IReadOnlyList<T>)

Variable.ShorterIsPrefixOfLonger<T>(IReadOnlyList<T>, IReadOnlyList<T>)

Variable.HasAnyItemDefined(IReadOnlyList<ConditionBlock>)

Variable.HasDefinedItem(IReadOnlyList<ConditionBlock>, List<List<IModelExpression>>, Int32)

Variable.MayOverlap(IReadOnlyList<IModelExpression>, IReadOnlyList<IModelExpression>)

Variable.IsConstantScalar(IModelExpression)

Variable.isObserved

Variable.IsObserved

Variable.HasObservedValue.ObservedValue

Variable.IsReadOnly

Variable.GetDomainType()

Variable.GetExpression()

Variable.attributes

Variable.AddAttribute(ICompilerAttribute)

Variable.AddAttribute(QueryType)

Variable.AddAttributes(ICompilerAttribute[])

Variable.AddAttributes(IEnumerable<ICompilerAttribute>)

Variable.AddDefinitionAttribute(ICompilerAttribute)

Variable.GetValueRange()

Variable.GetValueRange(Boolean)

Variable.SetValueRange(Range)

Variable.SetSparsity(Sparsity)

Variable.GetAttributes<AttributeType>()

Variable.RemoveAllAttributes<AttributeType>()

Variable.HasAttribute<AttributeType>()

Variable.GetFirstAttribute<AttributeType>()

Variable.GetContainers<T>()

Variable.array

Variable.ArrayVariable

Variable.IsArrayElement

Variable.GetItemExpression()

Variable.loopRange

Variable.IsLoopIndex

Variable.Constant<T>(T)

Variable.Constant<T>(T[])

Variable.Constant<T>(T[], Range)

Variable.Constant<T>(T[,])

Variable.Constant<T>(T[,], Range, Range)

Variable.Constant<T>(T[][], Range, Range)

Variable.Constant<T>(T[,][], Range, Range, Range)

Variable.Constant<T>(T[][][], Range, Range, Range)

Variable.Constant<T>(IList<T>)

Variable.Constant<T>(IList<T>, Range)

Variable.Constant<T>(IList<IList<T>>, Range, Range)

Variable.Constant<T>(IReadOnlyList<T>)

Variable.Constant<T>(IReadOnlyList<T>, Range)

Variable.Constant<T>(IReadOnlyList<IReadOnlyList<T>>, Range, Range)

Variable.Observed<T>(T)

Variable.Observed<T>(T[])

Variable.Observed<T>(T[,])

Variable.Observed<T>(T[], Range)

Variable.Observed<T>(T[][], Range, Range)

Variable.Observed<T>(T[][][], Range, Range, Range)

Variable.Observed<T>(T[][][][], Range, Range, Range, Range)

Variable.Observed<T>(T[,], Range, Range)

Variable.Observed<T>(IReadOnlyList<T>)

Variable.Observed<T>(IReadOnlyList<T>, Range)

Variable.Observed<T>(IReadOnlyList<IReadOnlyList<T>>, Range, Range)

Variable.Random<T>(IDistribution<T>)

Variable.Random<T, TDist>(Variable<TDist>)

Variable.New<T>()

Variable.ForEach(Range)

Variable.Repeat(Variable<Double>)

Variable.Array<T>(Range)

Variable.IList<T>(Range)

Variable.ISparseList<T>(Range)

Variable.IArray<T>(Range)

Variable.Array<T>(Range, Range)

Variable.IArray<T>(Range, Range)

Variable.Array<T>(Range, Range, Range)

Variable.Array<T>(IList<Range>)

Variable.Array<T>(VariableArray<T>, Range)

Variable.IList<T>(VariableArray<T>, Range)

Variable.IArray<T>(VariableArray<T>, Range)

Variable.Array<T>(VariableArray2D<T>, Range)

Variable.IArray<T>(VariableArray2D<T>, Range)

Variable.Array<T>(VariableArray<T>, Range, Range)

Variable.IArray<T>(VariableArray<T>, Range, Range)

Variable.Array<T>(VariableArray<T>, Range, Range, Range)

Variable.Array<TItem, TArray>(VariableArray<TItem, TArray>, Range)

Variable.IList<TItem, TArray>(VariableArray<TItem, TArray>, Range)

Variable.IArray<TItem, TArray>(VariableArray<TItem, TArray>, Range)

Variable.Array<TItem, TArray>(TItem, Range)

Variable.Constrain<T>(Action<T>, Variable<T>)

Variable.Constrain<T1, T2>(Action<T1, T2>, Variable<T1>, Variable<T2>)

Variable.Constrain<T1, T2, T3>(Action<T1, T2, T3>, Variable<T1>, Variable<T2>, Variable<T3>)

Variable.Constrain<T1, T2, T3, T4>(Action<T1, T2, T3, T4>, Variable<T1>, Variable<T2>, Variable<T3>, Variable<T4>)

Variable.ConstrainInternal(MethodInfo, Variable[])

Variable.GaussianFromMeanAndPrecision(Variable<Double>, Variable<Double>)

Variable.GaussianFromMeanAndPrecision(Double, Double)

Variable.GaussianFromMeanAndVariance(Variable<Double>, Variable<Double>)

Variable.GaussianFromMeanAndVariance(Variable<Double>, Double)

Variable.GaussianFromMeanAndVariance(Double, Double)

Variable.TruncatedGaussian(Double, Double, Double, Double)

Variable.TruncatedGammaFromShapeAndRate(Variable<Double>, Variable<Double>, Variable<Double>, Variable<Double>)

Variable.GaussianListFromMeanAndPrecision(Variable<ISparseList<Double>>, Variable<ISparseList<Double>>)

Variable.GaussianListFromMeanAndPrecision(ISparseList<Double>, Variable<ISparseList<Double>>)

Variable.GaussianListFromMeanAndPrecision(Variable<ISparseList<Double>>, ISparseList<Double>)

Variable.GaussianListFromMeanAndPrecision(ISparseList<Double>, ISparseList<Double>)

Variable.VectorGaussianFromMeanAndPrecision(Variable<Vector>, Variable<PositiveDefiniteMatrix>)

Variable.VectorGaussianFromMeanAndPrecision(Vector, PositiveDefiniteMatrix)

Variable.VectorGaussianFromMeanAndVariance(Vector, PositiveDefiniteMatrix)

Variable.VectorGaussianFromMeanAndVariance(Variable<Vector>, PositiveDefiniteMatrix)

Variable.VectorGaussianFromMeanAndVariance(Variable<Vector>, Variable<PositiveDefiniteMatrix>)

Variable.GammaFromShapeAndScale(Double, Double)

Variable.GammaFromShapeAndScale(Variable<Double>, Variable<Double>)

Variable.GammaFromShapeAndRate(Double, Double)

Variable.GammaFromShapeAndRate(Variable<Double>, Variable<Double>)

Variable.GammaFromMeanAndVariance(Double, Double)

Variable.GammaFromMeanAndVariance(Variable<Double>, Variable<Double>)

Variable.WishartFromShapeAndScale(Double, PositiveDefiniteMatrix)

Variable.WishartFromShapeAndScale(Variable<Double>, Variable<PositiveDefiniteMatrix>)

Variable.WishartFromShapeAndRate(Variable<Double>, Variable<PositiveDefiniteMatrix>)

Variable.Bernoulli(Double)

Variable.Bernoulli(Variable<Double>)

Variable.BernoulliList(Variable<ISparseList<Double>>)

Variable.BernoulliList(VariableArray<Variable<Boolean>, ISparseList<Double>>)

Variable.BernoulliList(ISparseList<Double>)

Variable.BernoulliIntegerSubset(Variable<ISparseList<Double>>)

Variable.BernoulliIntegerSubset(VariableArray<Variable<Double>, ISparseList<Double>>)

Variable.BernoulliIntegerSubset(ISparseList<Double>)

Variable.BernoulliFromLogOdds(Double)

Variable.BernoulliFromLogOdds(Variable<Double>)

Variable.Discrete(Double[])

Variable.Discrete(Range, Double[])

Variable.Discrete(Vector)

Variable.Discrete(Range, Vector)

Variable.DiscreteUniform(Int32)

Variable.DiscreteUniform(Range)

Variable.DiscreteUniform(Variable<Int32>)

Variable.DiscreteUniform(Range, Variable<Int32>)

Variable.Discrete(Variable<Vector>)

Variable.Discrete(Range, Variable<Vector>)

Variable.EnumDiscrete<TEnum>(Variable<Vector>)

Variable.EnumDiscrete<TEnum>(Double[])

Variable.EnumDiscrete<TEnum>(Range, Double[])

Variable.EnumDiscrete<TEnum>(Vector)

Variable.EnumDiscrete<TEnum>(Range, Vector)

Variable.EnumUniform<TEnum>()

Variable.EnumUniform<TEnum>(Range)

Variable.EnumToInt<TEnum>(Variable<TEnum>)

Variable.DiscreteFromLogProbs(VariableArray<Double>)

Variable.BetaFromMeanAndVariance(Double, Double)

Variable.BetaFromMeanAndVariance(Variable<Double>, Variable<Double>)

Variable.Beta(Double, Double)

Variable.Beta(Variable<Double>, Variable<Double>)

Variable.DirichletUniform(Int32)

Variable.DirichletUniform(Variable<Int32>)

Variable.DirichletUniform(Range)

Variable.DirichletSymmetric(Int32, Double)

Variable.DirichletSymmetric(Int32, Variable<Double>)

Variable.DirichletSymmetric(Range, Variable<Double>)

Variable.Dirichlet(Double[])

Variable.Dirichlet(Range, Double[])

Variable.Dirichlet(Vector)

Variable.Dirichlet(Variable<Vector>)

Variable.Dirichlet(Range, Vector)

Variable.Dirichlet(Range, Variable<Vector>)

Variable.Double(Variable<Int32>)

Variable.Double(IModelExpression<Int32>)

Variable.Double(Variable<Boolean>)

Variable.Poisson(Double)

Variable.Poisson(Variable<Double>)

Variable.Binomial(Int32, Variable<Double>)

Variable.Binomial(Variable<Int32>, Variable<Double>)

Variable.MultinomialList(Variable<Int32>, Variable<Vector>)

Variable.Multinomial(Variable<Int32>, Variable<Vector>)

Variable.Multinomial(Variable<Int32>, Vector)

Variable.Multinomial(Range, Variable<Vector>)

Variable.FunctionEvaluate(Variable<IFunction>, Variable<Vector>)

Variable.IsPositive(Variable<Double>)

Variable.IsBetween(Variable<Double>, Variable<Double>, Variable<Double>)

Variable.InnerProduct(Variable<Vector>, Variable<Vector>)

Variable.InnerProduct(Variable<Vector>, Variable<DenseVector>)

Variable.InnerProduct(Variable<DenseVector>, Variable<Vector>)

Variable.InnerProduct(VariableArray<Double>, Variable<Vector>)

Variable.InnerProduct(VariableArray<Double>, VariableArray<Double>)

Variable.SumWhere(VariableArray<Boolean>, Variable<Vector>)

Variable.SumWhere(VariableArray<Boolean>, VariableArray<Double>)

Variable.Matrix(Variable<Double[,]>)

Variable.MatrixTimesVector(Variable<Matrix>, Variable<Vector>)

Variable.MatrixTimesVector(Variable<Double[,]>, Variable<Vector>)

Variable.MatrixTimesScalar(Variable<PositiveDefiniteMatrix>, Variable<Double>)

Variable.VectorTimesScalar(Variable<Vector>, Variable<Double>)

Variable.MatrixMultiply(VariableArray2D<Double>, VariableArray2D<Double>)

Variable.Sum(Variable<Int32[]>)

Variable.Sum(Variable<IList<Double>>)

Variable.Sum(Variable<Double[]>)

Variable.Sum_Expanded(VariableArray<Double>)

Variable.Sum(Variable<IList<Vector>>)

Variable.Sum(Variable<Vector[]>)

Variable.Max(Variable<Double>, Variable<Double>)

Variable.Max(Variable<Int32>, Variable<Int32>)

Variable.Min(Variable<Double>, Variable<Double>)

Variable.Min(Variable<Int32>, Variable<Int32>)

Variable.Exp(Variable<Double>)

Variable.Log(Variable<Double>)

Variable.Logistic(Variable<Double>)

Variable.Softmax(VariableArray<Double>)

Variable.Softmax(Variable<IList<Double>>)

Variable.Softmax(Variable<Vector>)

Variable.Softmax(Variable<ISparseList<Double>>)

Variable.ProductExp(Variable<Double>, Variable<Double>)

Variable.Rotate(Variable<Double>, Variable<Double>, Variable<Double>)

Variable.AllTrue(Variable<IList<Boolean>>)

Variable.AllTrue(Variable<Boolean[]>)

Variable.CountTrue(Variable<Boolean[]>)

Variable.Concat(Variable<Vector>, Variable<Vector>)

Variable.Vector(Variable<Double[]>)

Variable.ArrayFromVector(Variable<Vector>, Range)

Variable.Split<T>(VariableArray<T>, Range, Range, VariableArray<T>)

Variable.Split<TItem, T>(VariableArray<TItem, T[]>, Range, Range, VariableArray<TItem, T[]>)

Variable.Subvector(Variable<Vector>, Variable<Int32>, Variable<Int32>)

Variable.GetItem(Variable<Vector>, Variable<Int32>)

Variable.Copy<T>(Variable<T>)

Variable.Copy<T>(VariableArray<T>)

Variable.Copy<T>(VariableArray<VariableArray<T>, T[][]>)

Variable.Copy<TItem, T>(VariableArray<VariableArray<TItem, T>, T[]>)

Variable.SequentialCopy<T>(Variable<T>, Variable<T>)

Variable.SequentialCopy<T>(VariableArray<T>, VariableArray<T>)

Variable.SequentialCopy<T>(VariableArray<VariableArray<T>, T[][]>, VariableArray<VariableArray<T>, T[][]>)

Variable.CutForwardWhen<T>(Variable<T>, Variable<Boolean>)

Variable.Cut<T>(Variable<T>)

Variable.Cut<T>(VariableArray<T>)

Variable.Cut<T>(VariableArray<VariableArray<T>, T[][]>)

Variable.Replicate<T>(Variable<T>, Range)

Variable.Replicate<T>(VariableArray<T>, Range)

Variable.Replicate<T>(VariableArray<VariableArray<T>, T[][]>, Range)

Variable.Replicate<TItem, T>(VariableArray<VariableArray<TItem, T>, T[]>, Range)

Variable.Subarray<T>(Variable<T[]>, VariableArray<Int32>)

Variable.Subarray<T>(Variable<IReadOnlyList<T>>, VariableArray<Int32>)

Variable.Subarray<T>(VariableArray<T>, VariableArray<Int32>)

Variable.Subarray2<T>(VariableArray<T>, VariableArray<Int32>, VariableArray<T>)

Variable.Subarray<T>(VariableArray<T>, VariableArray<Variable<Int32>, IReadOnlyList<Int32>>)

Variable.SplitSubarray<T>(VariableArray<T>, VariableArray<VariableArray<Int32>, Int32[][]>)

Variable.SplitSubarray<TItem, T>(VariableArray<TItem, T[]>, VariableArray<VariableArray<Int32>, Int32[][]>)

Variable.JaggedSubarray<T>(VariableArray<T>, VariableArray<VariableArray<Int32>, Int32[][]>)

Variable.Subarray<TItem, T>(VariableArray<TItem, T[]>, VariableArray<Int32>)

Variable.GetItems<T>(Variable<T[]>, VariableArray<Int32>)

Variable.GetItems<T>(Variable<IReadOnlyList<T>>, VariableArray<Int32>)

Variable.GetItems<T>(VariableArray<T>, VariableArray<Int32>)

Variable.GetItems<TItem, T>(VariableArray<TItem, T[]>, VariableArray<Int32>)

Variable.Char(Variable<Vector>)

Variable.CharUniform()

Variable.CharLower()

Variable.CharUpper()

Variable.CharLetter()

Variable.CharDigit()

Variable.CharLetterOrDigit()

Variable.CharWord()

Variable.CharNonWord()

Variable.CharWhitespace()

Variable.StringUniform()

Variable.StringLower()

Variable.StringLower(Variable<Int32>, Variable<Int32>)

Variable.StringUpper()

Variable.StringUpper(Variable<Int32>, Variable<Int32>)

Variable.StringLetters()

Variable.StringLetters(Variable<Int32>, Variable<Int32>)

Variable.StringDigits()

Variable.StringDigits(Variable<Int32>, Variable<Int32>)

Variable.StringLettersOrDigits()

Variable.StringLettersOrDigits(Variable<Int32>, Variable<Int32>)

Variable.StringWhitespace()

Variable.StringWhitespace(Variable<Int32>, Variable<Int32>)

Variable.StringWord()

Variable.StringWord(Variable<Int32>, Variable<Int32>)

Variable.StringNonWord()

Variable.StringNonWord(Variable<Int32>, Variable<Int32>)

Variable.StringCapitalized()

Variable.StringCapitalized(Variable<Int32>, Variable<Int32>)

Variable.StringOfLength(Variable<Int32>)

Variable.StringOfLength(Variable<Int32>, Variable<DiscreteChar>)

Variable.String(Variable<Int32>, Variable<Int32>)

Variable.String(Variable<Int32>, Variable<Int32>, Variable<DiscreteChar>)

Variable.StringFromArray(VariableArray<Char>)

Variable.Substring(Variable<String>, Variable<Int32>, Variable<Int32>)

Variable.StringFormat(Variable<String>, Variable<String>[])

Variable.StringFormat(Variable<String>, VariableArray<String>)

Variable.GetItem(Variable<String>, Variable<Int32>)

Variable.ConstrainTrue(Variable<Boolean>)

Variable.ConstrainFalse(Variable<Boolean>)

Variable.ConstrainPositive(Variable<Double>)

Variable.ConstrainBetween(Variable<Double>, Variable<Double>, Variable<Double>)

Variable.ConstrainEqual<T>(Variable<T>, Variable<T>)

Variable.ConstrainEqual<T>(T, Variable<T>)

Variable.ConstrainEqual<T>(Variable<T>, T)

Variable.ConstrainEqualRandom<T, TDist>(Variable<T>, Variable<TDist>)

Variable.ConstrainEqualRandom<T, TDist>(T, Variable<TDist>)

Variable.ConstrainEqualRandom<T, TDist>(Variable<T>, TDist)

Variable.Potts(Variable<Boolean>, Variable<Boolean>, Variable<Double>)

Variable.Potts(Variable<Int32>, Variable<Int32>, Variable<Double>)

Variable.Linear(Variable<Int32>, Variable<Int32>, Variable<Double>)

Variable.LinearTrunc(Variable<Int32>, Variable<Int32>, Variable<Double>, Variable<Double>)

Variable.operatorFactorRegistry

Variable.RegisterOperatorFactor(Variable.Operator, Delegate)

Variable.LookupOperatorFactor(Variable.Operator, Type[])

Variable.If(Variable<Boolean>)

Variable.IfNot(Variable<Boolean>)

Variable.Case(Variable<Int32>, Int32)

Variable.CloseAllBlocks()

Variable.Switch(Variable<Int32>)

Object.Equals(Object)

Object.Equals(Object, Object)

Object.GetHashCode()

Object.GetType()

Object.MemberwiseClone()

Object.ReferenceEquals(Object, Object)

Namespace: Microsoft.ML.Probabilistic.Models

Assembly: Microsoft.ML.Probabilistic.Compiler.dll

Syntax

public class VariableArray<T> : VariableArray<Variable<T>, T[]>, CanGetContainers, IModelExpression<T[]>, SettableTo<Variable<T[]>>, ICloneable, HasItemVariables, IVariableJaggedArray, SettableTo<VariableArray<Variable<T>, T[]>>, IVariableArray<T>, IJaggedVariableArray<Variable<T>>, SettableTo<VariableArray<T>>, IVariableArray, IVariable, IModelExpression, HasObservedValue

Type Parameters

Name	Description
T

Constructors

VariableArray(VariableArray<T>)

Copy constructor.

Declaration

protected VariableArray(VariableArray<T> that)

Parameters

Type	Name	Description
VariableArray<T>	that

Methods

Attrib(ICompilerAttribute)

Inline method for adding an attribute to a random variable. This method returns the random variable object, so that is can be used in an inline expression. e.g. Variable.GaussianFromMeanAndVariance(0,1).Attrib(new MyAttribute());

Declaration

public VariableArray<T> Attrib(ICompilerAttribute attr)

Parameters

Type	Name	Description
ICompilerAttribute	attr	The attribute to add

Returns

Type	Description
VariableArray<T>	The random variable object

Attrib(QueryType)

Helper to add a query type attribute to this variable.

Declaration

public VariableArray<T> Attrib(QueryType queryType)

Parameters

Type	Name	Description
QueryType	queryType	The query type to use to create the attribute

Returns

Type	Description
VariableArray<T>

Clone()

Clone the array

Declaration

public override object Clone()

Returns

Type	Description
Object

Overrides

Microsoft.ML.Probabilistic.Models.VariableArray<Microsoft.ML.Probabilistic.Models.Variable<T>, T[]>.Clone()

Named(String)

Set the name of the array.

Declaration

public VariableArray<T> Named(string name)

Parameters

Type	Name	Description
String	name

Returns

Type	Description
VariableArray<T>	this

SetTo(VariableArray<T>)

Set the 1-D array to the given value

Declaration

public void SetTo(VariableArray<T> that)

Parameters

Type	Name	Description
VariableArray<T>	that

Explicit Interface Implementations

IVariableArray.ReplaceRanges(Dictionary<Range, Range>, Dictionary<IModelExpression, IModelExpression>, Boolean)

Declaration

IVariableArray IVariableArray.ReplaceRanges(Dictionary<Range, Range> rangeReplacements, Dictionary<IModelExpression, IModelExpression> expressionReplacements, bool deepCopy)

Parameters

Type	Name	Description
Dictionary<Range, Range>	rangeReplacements
Dictionary<IModelExpression, IModelExpression>	expressionReplacements
Boolean	deepCopy

Returns

Type	Description
IVariableArray

Implements

CanGetContainers

IModelExpression<T>

SettableTo<T>

System.ICloneable

HasItemVariables

IVariableJaggedArray

SettableTo<T>

IVariableArray<T>

IJaggedVariableArray<TItem>

SettableTo<T>

IVariableArray

IVariable

IModelExpression

HasObservedValue