// By default, set the weight to 1.0
 public GaussianWeightedSumFactor(Variable<GaussianDistribution> sumVariable,
     Variable<GaussianDistribution>[] variablesToSum)
     : this(sumVariable,
            variablesToSum,
            variablesToSum.Select(v => 1.0).ToArray())
 {
 }
 public GaussianWeightedSumFactor(Variable<GaussianDistribution> sumVariable,
                                  Variable<GaussianDistribution>[] variablesToSum)
     : this(sumVariable,
            variablesToSum,
            variablesToSum.Select(v => 1.0).ToArray()) // By default, set the weight to 1.0
 {
 }
Example #3
0
        public static FunctionTerm VectorScaling(int dimension)
        {
            if (dimension < 0)
            {
                throw new ArgumentOutOfRangeException("dimension");
            }

            Variable c = new Variable(1, "c");
            Variable x = new Variable(dimension, "x");

            return(new FunctionDefinition
                   (
                       string.Format("vector_scaling_{0}", dimension),
                       Vector
                       (
                           from index in Enumerable.Range(0, dimension)
                           select ApplyProduct(c, x.Select(index))
                       )
                       .Abstract(c, x),
                       new BasicBinaryOperatorSyntax("⊛")
                   ));
        }
Example #4
0
        public static FunctionTerm VectorSum(int dimension)
        {
            if (dimension < 0)
            {
                throw new ArgumentOutOfRangeException("dimension");
            }

            Variable x = new Variable(dimension, "x");
            Variable y = new Variable(dimension, "y");

            return(new FunctionDefinition
                   (
                       string.Format("vector_sum_{0}", dimension),
                       Vector
                       (
                           from index in Enumerable.Range(0, dimension)
                           select ApplySum(x.Select(index), y.Select(index))
                       )
                       .Abstract(x, y),
                       new BasicBinaryOperatorSyntax("⊕")
                   ));
        }
        public void BeginMethod(string name, IrisType returnType, Variable[] parameters, Variable[] locals, bool entryPoint)
        {
            string cilName = string.Format(
                "{0} {1}({2})",
                IrisTypeToCilTypeName(returnType),
                name,
                string.Join(", ", parameters.Select(v => IrisVarToCilVar(v))));

            WriteIndentedText(string.Format(".method public hidebysig static {0} cil managed", cilName));
            WriteIndentedText("{");

            _indentLevel++;

            if (entryPoint)
            {
                WriteIndentedText(".entrypoint");
            }

            if (locals.Length > 0)
            {
                StringBuilder localsBuilder = new StringBuilder();
                localsBuilder.Append(".locals init (");

                int localIndex = 0;
                foreach (Variable var in locals)
                {
                    if (localIndex != 0)
                        localsBuilder.Append(", ");

                    localsBuilder.AppendFormat("[{0}] {1}", localIndex, IrisVarToCilVar(var));
                    localIndex++;
                }

                localsBuilder.Append(")");
                WriteIndentedText(localsBuilder.ToString());
            }
        }
Example #6
0
        public double[] Differentiate(Variable[] vars, params double[] values)
        {
            MakeDifferentiation(vars);

            return vars.Select(v => v.Derivative.Evaluate(values)).ToArray();
        }