Class VariableArrayBase<TItem, TArray>

Represents a jagged variable array of arbitrary rank

Inheritance

Object

Variable

Variable<TArray>

VariableArrayBase<TItem, TArray>

VariableArray<TItem, TArray>

VariableArray2D<TItem, TArray>

VariableArray3D<TItem, TArray>

Implements

CanGetContainers

IModelExpression<TArray>

SettableTo<Variable<TArray>>

ICloneable

HasItemVariables

IVariableArray

IVariable

IModelExpression

HasObservedValue

IVariableJaggedArray

Inherited Members

Variable<TArray>.isReadOnly

Variable<TArray>.IsReadOnly

Variable<TArray>.observedValue

Variable<TArray>.HasObservedValue.ObservedValue

Variable<TArray>.ObservedValue

Variable<TArray>.ClearObservedValue()

Variable<TArray>.Clone()

Variable<TArray>.SetTo(Variable<TArray>)

Variable<TArray>.declaration

Variable<TArray>.Name

Variable<TArray>.IModelExpression.Name

Variable<TArray>.Named(String)

Variable<TArray>.Attrib(ICompilerAttribute)

Variable<TArray>.Attrib(QueryType)

Variable<TArray>.InitialiseTo<TDist>(TDist)

Variable<TArray>.InitialiseTo<TDist>(Variable<TDist>)

Variable<TArray>.InitialiseTo<TDist>(IModelExpression<TDist>)

Variable<TArray>.InitialiseBackwardTo<TDist>(TDist)

Variable<TArray>.InitialiseBackwardTo<TDist>(Variable<TDist>)

Variable<TArray>.InitialiseBackwardTo<TDist>(IModelExpression<TDist>)

Variable<TArray>.SetMarginalPrototype<TDist>(IModelExpression<TDist>)

Variable<TArray>.ForEach(Range)

Variable<TArray>.ForEach(Range[])

Variable<TArray>.Array(Range)

Variable<TArray>.Random<TDist>(Variable<TDist>)

Variable<TArray>.Factor(Func<TArray>)

Variable<TArray>.Factor<T1>(Func<T1, TArray>, Variable<T1>)

Variable<TArray>.Factor<T1>(Func<T1, TArray>, T1)

Variable<TArray>.Factor<T1, T2>(Func<T1, T2, TArray>, Variable<T1>, Variable<T2>)

Variable<TArray>.Factor<T1, T2>(FuncOut<T1, T2, TArray>, Variable<T1>, Variable<T2>)

Variable<TArray>.Factor<T1, T2>(Func<T1, T2, TArray>, T1, Variable<T2>)

Variable<TArray>.Factor<T1, T2>(Func<T1, T2, TArray>, Variable<T1>, T2)

Variable<TArray>.Factor<T1, T2>(Func<T1, T2, TArray>, T1, T2)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, Variable<T1>, Variable<T2>, Variable<T3>)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, T1, Variable<T2>, Variable<T3>)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, T1, T2, Variable<T3>)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, T1, Variable<T2>, T3)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, Variable<T1>, T2, Variable<T3>)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, Variable<T1>, Variable<T2>, T3)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, Variable<T1>, T2, T3)

Variable<TArray>.Factor<T1, T2, T3>(Func<T1, T2, T3, TArray>, T1, T2, T3)

Variable<TArray>.Factor<T1, T2, T3, T4>(Func<T1, T2, T3, T4, TArray>, Variable<T1>, Variable<T2>, Variable<T3>, Variable<T4>)

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

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

Variable<TArray>.GreaterThan(Variable<TArray>, Variable<TArray>)

Variable<TArray>.GreaterThanOrEqual(Variable<TArray>, Variable<TArray>)

Variable.NameInGeneratedCode

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.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.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 abstract class VariableArrayBase<TItem, TArray> : Variable<TArray>, CanGetContainers, IModelExpression<TArray>, SettableTo<Variable<TArray>>, ICloneable, HasItemVariables, IVariableArray, IVariable, IModelExpression, HasObservedValue, IVariableJaggedArray where TItem : Variable, ICloneable, SettableTo<TItem>

Type Parameters

Name	Description
TItem	The item variable type.
TArray	The domain type of the array.

Remarks

TItem is either a VariableArray<T> or another VariableArray<,>

Constructors

VariableArrayBase(VariableArrayBase<TItem, TArray>)

Copy constructor.

Declaration

protected VariableArrayBase(VariableArrayBase<TItem, TArray> array)

Parameters

Type	Name	Description
VariableArrayBase<TItem, TArray>	array

Fields

itemPrototype

Declaration

protected TItem itemPrototype

Field Value

Type	Description
TItem

Properties

Item[IModelExpression[]]

Declaration

protected TItem this[params IModelExpression[] index] { get; set; }

Parameters

Type	Name	Description
IModelExpression[]	index

Property Value

Type	Description
TItem

Item[Range[]]

Declaration

protected TItem this[params Range[] index] { get; set; }

Parameters

Type	Name	Description
Range[]	index

Property Value

Type	Description
TItem

Ranges

List of ranges associated with the array

Declaration

public IList<Range> Ranges { get; }

Property Value

Type	Description
IList<Range>

Methods

SetTo(VariableArrayBase<TItem, TArray>)

Set the variable array to the given value

Declaration

public void SetTo(VariableArrayBase<TItem, TArray> that)

Parameters

Type	Name	Description
VariableArrayBase<TItem, TArray>	that

Explicit Interface Implementations

HasItemVariables.GetItemsUntyped()

Declaration

Dictionary<IReadOnlyList<IModelExpression>, IVariable> HasItemVariables.GetItemsUntyped()

Returns

Type	Description
Dictionary<IReadOnlyList<IModelExpression>, IVariable>

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

IVariableJaggedArray.ItemPrototype

Declaration

IVariable IVariableJaggedArray.ItemPrototype { get; }

Returns

Type	Description
IVariable

Implements

CanGetContainers

IModelExpression<T>

SettableTo<T>

System.ICloneable

HasItemVariables

IVariableArray

IVariable

IModelExpression

HasObservedValue

IVariableJaggedArray