Class VariableArray3D<T>

Three-dimensional flat variable array.

Inheritance

Object

Variable

Variable<T[,]>

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

VariableArray3D<Variable<T>, T[,]>

VariableArray3D<T>

Implements

CanGetContainers

IModelExpression<T[,]>

SettableTo<Variable<T[,]>>

ICloneable

HasItemVariables

IVariableJaggedArray

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

IVariableArray3D<T>

IVariableArray

IVariable

IModelExpression

HasObservedValue

SettableTo<VariableArray3D<T>>

Inherited Members

VariableArray3D<Variable<T>, T[,]>.Range0

VariableArray3D<Variable<T>, T[,]>.Range1

VariableArray3D<Variable<T>, T[,]>.Range2

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

VariableArray3D<Variable<T>, T[,]>.Item[Variable<Int32>, Range, Range]

VariableArray3D<Variable<T>, T[,]>.Item[Variable<Int32>, Variable<Int32>, Range]

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

VariableArray3D<Variable<T>, T[,]>.Item[Variable<Int32>, Range, Variable<Int32>]

VariableArray3D<Variable<T>, T[,]>.Item[Range, Variable<Int32>, Range]

VariableArray3D<Variable<T>, T[,]>.Item[Range, Range, Variable<Int32>]

VariableArray3D<Variable<T>, T[,]>.Item[Range, Variable<Int32>, Variable<Int32>]

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

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

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

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

VariableArray3D<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 VariableArray3D<T> : VariableArray3D<Variable<T>, T[, ]>, CanGetContainers, IModelExpression<T[, ]>, SettableTo<Variable<T[, ]>>, ICloneable, HasItemVariables, IVariableJaggedArray, SettableTo<VariableArray3D<Variable<T>, T[, ]>>, IVariableArray3D<T>, IVariableArray, IVariable, IModelExpression, HasObservedValue, SettableTo<VariableArray3D<T>>

Type Parameters

Name	Description
T

Constructors

VariableArray3D(VariableArray3D<T>)

Copy constructor.

Declaration

protected VariableArray3D(VariableArray3D<T> that)

Parameters

Type	Name	Description
VariableArray3D<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 VariableArray3D<T> Attrib(ICompilerAttribute attr)

Parameters

Type	Name	Description
ICompilerAttribute	attr	The attribute to add

Returns

Type	Description
VariableArray3D<T>	The random variable object

Clone()

Clone the 3-D array

Declaration

public override object Clone()

Returns

Type	Description
Object

Overrides

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

Named(String)

Set the name of the array.

Declaration

public VariableArray3D<T> Named(string name)

Parameters

Type	Name	Description
String	name

Returns

Type	Description
VariableArray3D<T>	this

SetTo(VariableArray3D<T>)

Set the 3-D array to a specified value

Declaration

public void SetTo(VariableArray3D<T> that)

Parameters

Type	Name	Description
VariableArray3D<T>	that

Explicit Interface Implementations

IVariableArray3D<T>.Item[IModelExpression, IModelExpression, IModelExpression]

Sets/Gets element in array given by the index expressions

Declaration

Variable<T> IVariableArray3D<T>.this[IModelExpression index0, IModelExpression index1, IModelExpression index2] { get; set; }

Parameters

Type	Name	Description
IModelExpression	index0	First index expression
IModelExpression	index1	Second index expression
IModelExpression	index2	Third index expression

Returns

Type	Description
Variable<T>

Implements

CanGetContainers

IModelExpression<T>

SettableTo<T>

System.ICloneable

HasItemVariables

IVariableJaggedArray

SettableTo<T>

IVariableArray3D<T>

IVariableArray

IVariable

IModelExpression

HasObservedValue

SettableTo<T>