Пример #1
0
        public SetValue Function(StringValue name, ArgumentsValue args)
        {
            var set = new SetValue(name.Value, null, false);

            int iArgs = 1; //First is "name"
            foreach (var arg in args)
            {
                iArgs++;
                if (arg is MatrixValue)
                {
                    set.AddElements((arg as MatrixValue).ToArray());
                }
                else if (arg is StringValue)
                {
                    set.Set.Add((arg as StringValue).Value);
                }
                else if (arg is NumericValue)
                {
                    set.Set.Add(arg as NumericValue);
                }
                else
                    throw new YAMPArgumentInvalidException("Element is not ScalarValue, StringValue or MatrixValue", iArgs);
            }
            return set;
        }
Пример #2
0
        public MatrixValue Function(FunctionValue f, ScalarValue n, ScalarValue dt, ArgumentsValue args)
        {
            var numberOfMeasurements    = (Int32)n.Value;
            var timeBetweenMeasurements = (Int32)Math.Floor(dt.Value * 1000);
            var results = new MatrixValue(numberOfMeasurements, 2);
            var time    = 0.0;

            for (var i = 1; i <= numberOfMeasurements; i++)
            {
                Thread.Sleep(timeBetweenMeasurements);

                var result = f.Perform(context, args);
                results[i, 1] = new ScalarValue(time);

                if (result is ScalarValue)
                {
                    results[i, 2] = result as ScalarValue;
                }
                else if (result is MatrixValue)
                {
                    var m = result as MatrixValue;

                    for (var j = 1; j <= m.Length; j++)
                    {
                        results[i, 1 + j] = m[j];
                    }
                }

                time += dt.Value;
            }

            return(results);
        }
Пример #3
0
        /// <summary>
        /// Create a new Set, with the Symmetric Except(XOR) of all Sets
        /// </summary>
        /// <param name="set">The set</param>
        /// <param name="args">Sets to Except(XOR)</param>
        /// <returns>The new set</returns>
        internal static SetValue TExceptXor(SetValue set, ArgumentsValue args)
        {
            string newName = string.Format("({0}", set.Name);

            var newSet = set.Copy() as SetValue;

            int iArgs = 1; //First is "name"

            foreach (var arg in args)
            {
                iArgs++;
                SetValue otherSet = arg as SetValue;
                newName += string.Format("^{0}", otherSet.Name);
                if (!ReferenceEquals(otherSet, null))
                {
                    newSet.Set.SymmetricExceptWith(otherSet.Set);
                }
                else
                {
                    throw new YAMPArgumentInvalidException("Element is not SetValue", iArgs);
                }
            }
            newName    += ")";
            newSet.Name = newName;

            return(newSet);
        }
Пример #4
0
        public SetValue Function(StringValue name, ArgumentsValue args)
        {
            var set = new SetValue(name.Value, null, false);

            int iArgs = 1; //First is "name"

            foreach (var arg in args)
            {
                iArgs++;
                if (arg is MatrixValue)
                {
                    set.AddElements((arg as MatrixValue).ToArray());
                }
                else if (arg is StringValue)
                {
                    set.Set.Add((arg as StringValue).Value);
                }
                else if (arg is NumericValue)
                {
                    set.Set.Add(arg as NumericValue);
                }
                else
                {
                    throw new YAMPArgumentInvalidException("Element is not ScalarValue, StringValue or MatrixValue", iArgs);
                }
            }
            return(set);
        }
Пример #5
0
        public MatrixValue Function(ArgumentsValue values)
        {
            var m = new MatrixValue();

            for (var i = 1; i <= values.Length; i++)
            {
                var sy = m.DimensionY;
                var sx = m.DimensionX;

                if (values[i] is ScalarValue)
                {
                    var s = (ScalarValue)values[i];
                    m[sy + 1, sx + 1] = s.Clone();
                }
                else if (values[i] is MatrixValue)
                {
                    var n = (MatrixValue)values[i];

                    for (var l = 1; l <= n.DimensionX; l++)
                    {
                        for (var k = 1; k <= n.DimensionY; k++)
                        {
                            m[sy + k, sx + l] = n[k, l].Clone();
                        }
                    }
                }
                else
                {
                    throw new YAMPArgumentInvalidException(Name, values[i].Header, i);
                }
            }

            return m;
        }
Пример #6
0
        public MatrixValue Function(FunctionValue f, ScalarValue n, ScalarValue dt, ArgumentsValue args)
        {
            var numberOfMeasurements = (Int32)n.Value;
            var timeBetweenMeasurements = (Int32)Math.Floor(dt.Value * 1000);
            var results = new MatrixValue(numberOfMeasurements, 2);
            var time = 0.0;

            for (var i = 1; i <= numberOfMeasurements; i++)
            {
                Thread.Sleep(timeBetweenMeasurements);

                var result = f.Perform(context, args);
                results[i, 1] = new ScalarValue(time);

                if (result is ScalarValue)
                {
                    results[i, 2] = result as ScalarValue;
                }
                else if (result is MatrixValue)
                {
                    var m = result as MatrixValue;

                    for (var j = 1; j <= m.Length; j++)
                    {
                        results[i, 1 + j] = m[j];
                    }
                }

                time += dt.Value;
            }

            return results;
        }
Пример #7
0
            public SetValue Function(ArgumentsValue args)
            {
                SetValue set = @this as SetValue;

                if (ReferenceEquals(set, null))
                {
                    throw new YAMPSetsFunctionNotMemberException("SetIntersect");
                }

                return(SetValue.TIntersect(set, args));
            }
Пример #8
0
        public MatrixValue Function(StringValue f, ScalarValue n, ScalarValue dt, ArgumentsValue args)
        {
            var function = GetSensorFunction(f.Value);

            if (function == null)
            {
                throw new YAMPRuntimeException("The given function {0} could not be found.", f.Value);
            }

            return Function(new FunctionValue(function), n, dt, args);
        }
Пример #9
0
        public MatrixValue Function(StringValue f, ScalarValue n, ScalarValue dt, ArgumentsValue args)
        {
            var function = GetSensorFunction(f.Value);

            if (function == null)
            {
                throw new YAMPRuntimeException("The given function {0} could not be found.", f.Value);
            }

            return(Function(new FunctionValue(function), n, dt, args));
        }
Пример #10
0
        public void Function(StringValue fileName, ArgumentsValue args)
        {
            var workspace = new Dictionary <String, Value>();

            foreach (var arg in args.Values)
            {
                if (arg is StringValue)
                {
                    var name = (arg as StringValue).Value;

                    if (Context.Variables.ContainsKey(name))
                    {
                        workspace.Add(name, Context.Variables[name]);
                    }
                }
            }

            Save(fileName.Value, workspace);
            Notify(workspace.Count);
        }
Пример #11
0
        public Plot2DValue Function(MatrixValue m, MatrixValue n, ArgumentsValue l)
        {
            var plot = new Plot2DValue();
            var values = new MatrixValue[l.Length];

            for (var i = 0; i != l.Length; i++)
            {
                if (l.Values[i] is MatrixValue)
                {
                    values[i] = (MatrixValue)l.Values[i];
                }
                else
                {
                    throw new YAMPOperationInvalidException("plot", l.Values[i]);
                }
            }

            plot.AddPoints(m, n, values);
            return plot;
        }
Пример #12
0
        public void Function(StringValue fileName, ArgumentsValue args)
        {
            var workspace = new Dictionary<String, Value>();

            foreach (var arg in args.Values)
            {
                if (arg is StringValue)
                {
                    var name = (arg as StringValue).Value;

                    if (Context.Variables.ContainsKey(name))
                    {
                        workspace.Add(name, Context.Variables[name]);
                    }
                }
            }

            Save(fileName.Value, workspace);
            Notify(workspace.Count);
        }
Пример #13
0
        public void Function(ArgumentsValue args)
        {
            var count = 0;
            var allVariables = Context.AllVariables.Keys;

            foreach (var arg in args.Values)
            {
                if (arg is StringValue)
                {
                    var name = (arg as StringValue).Value;

                    if (allVariables.Contains(name))
                    {
                        Context.AssignVariable(name, null);
                        count++;
                    }
                }
            }

            Notify(count);
        }
Пример #14
0
        public StringValue Function(ArgumentsValue filter)
        {
            var values = filter.Values;
            var index = 0;
            var sb = new StringBuilder();

            foreach (var value in values)
            {
                index++;

                if (value is StringValue)
                {
                    var str = value as StringValue;
                    sb.Append(Function(str));
                }
                else
                {
                    throw new YAMPArgumentWrongTypeException(value.Header, "String", Name);
                }
            }

            return new StringValue(sb.ToString());
        }
Пример #15
0
 public SetValue Function(SetValue set1, ArgumentsValue args)
 {
     return(SetValue.TUnion(set1, args));
 }
Пример #16
0
        public void Function(StringValue filename, ArgumentsValue args)
        {
            if (!File.Exists(filename.Value))
                throw new YAMPFileNotFoundException(filename.Value);

            var error = false;
            var v = Load(filename.Value, out error);
            var count = 0;

            if(!error)
            {
                foreach (var arg in args.Values)
                {
                    if (arg is StringValue)
                    {
                        var name = (arg as StringValue).Value;

                        if (v.ContainsKey(name))
                        {
                            Context.AssignVariable(name, v[name] as Value);
                            count++;
                        }
                    }
                }
            }

            if (error)
            {
                var table = ImageLoad(filename.Value, out error);

                if (!error)
                {
                    var name = "image";

                    if (args.Length > 0 && args.Values[0] is StringValue)
                    {
                        name = (args.Values[0] as StringValue).Value;
                    }
                    else
                    {
                        var suffix = -1;

                        do
                        {
                            suffix++;
                        }
                        while (Context.Variables.ContainsKey(name + suffix));

                        name = name + suffix;
                    }

                    Context.AssignVariable(name, table);
                    count = 1;
                }
            }

            if (error)
            {
                var table = ASCIILoad(filename.Value, out error);

                if (!error)
                {
                    var name = "data";

                    if (args.Length > 0 && args.Values[0] is StringValue)
                    {
                        name = (args.Values[0] as StringValue).Value;
                    }
                    else
                    {
                        var suffix = -1;

                        do
                        {
                            suffix++;
                        }
                        while (Context.Variables.ContainsKey(name + suffix));

                        name = name + suffix;
                    }

                    Context.AssignVariable(name, table);
                    count = 1;
                }
            }

            if (error)
            {
                throw new YAMPFileFormatNotSupportedException(filename.Value);
            }

            Notify(count);
        }
Пример #17
0
 public StringValue Function(StringValue text, ArgumentsValue args)
 {
     return new StringValue(String.Format(text.Value, args.ToArray()));
 }
Пример #18
0
        public void Function(StringValue filename, ArgumentsValue args)
        {
            if (!File.Exists(filename.Value))
            {
                throw new YAMPFileNotFoundException(filename.Value);
            }

            var error = false;
            var v     = Load(filename.Value, out error);
            var count = 0;

            if (!error)
            {
                foreach (var arg in args.Values)
                {
                    if (arg is StringValue)
                    {
                        var name = (arg as StringValue).Value;

                        if (v.ContainsKey(name))
                        {
                            Context.AssignVariable(name, v[name] as Value);
                            count++;
                        }
                    }
                }
            }

            if (error)
            {
                var table = ImageLoad(filename.Value, out error);

                if (!error)
                {
                    var name = "image";

                    if (args.Length > 0 && args.Values[0] is StringValue)
                    {
                        name = (args.Values[0] as StringValue).Value;
                    }
                    else
                    {
                        var suffix = -1;

                        do
                        {
                            suffix++;
                        }while (Context.Variables.ContainsKey(name + suffix));

                        name = name + suffix;
                    }

                    Context.AssignVariable(name, table);
                    count = 1;
                }
            }

            if (error)
            {
                var table = ASCIILoad(filename.Value, out error);

                if (!error)
                {
                    var name = "data";

                    if (args.Length > 0 && args.Values[0] is StringValue)
                    {
                        name = (args.Values[0] as StringValue).Value;
                    }
                    else
                    {
                        var suffix = -1;

                        do
                        {
                            suffix++;
                        }while (Context.Variables.ContainsKey(name + suffix));

                        name = name + suffix;
                    }

                    Context.AssignVariable(name, table);
                    count = 1;
                }
            }

            if (error)
            {
                throw new YAMPFileFormatNotSupportedException(filename.Value);
            }

            Notify(count);
        }
Пример #19
0
 public SetValue Function(SetValue set1, ArgumentsValue args)
 {
     return SetValue.TExceptXor(set1, args);
 }
Пример #20
0
 public void Function(StringValue text, ArgumentsValue args)
 {
     var content = String.Format(text.Value, args.ToArray());
     Context.RaiseNotification(new NotificationEventArgs(NotificationType.Message, content));
 }
Пример #21
0
 public ArgumentsValue Function(StringValue text, ArgumentsValue args)
 {
     var separators = args.Select(v => v.ToString()).ToArray();
     var tokens = text.ToString().Split(separators, StringSplitOptions.RemoveEmptyEntries);
     return new ArgumentsValue(tokens.Select(s => new StringValue(s)).ToArray());
 }
Пример #22
0
        public MatrixValue Function(MatrixValue cfgs, ScalarValue n, FunctionValue f, ArgumentsValue P)
        {
            var numberOfBootstrapSamples = n.GetIntegerOrThrowException("n", Name);
            var nConfigs = cfgs.DimensionY;
            var nData = cfgs.DimensionX;
            var distribution = new DiscreteUniformDistribution(Rng)
            {
                Beta = nConfigs,
                Alpha = 1
            };

            if (numberOfBootstrapSamples <= 1)
                throw new YAMPException("Bootstrap: The number of bootstrap samples n is smaller or equal to 1!");

            var parameters = new ArgumentsValue(cfgs);

            foreach (var m in P.Values)
            {
                parameters.Insert(m);
            }

            var temp = f.Perform(Context, parameters);
            var nResult = 0;//dimension of the result

            if (temp is ScalarValue)
            {
                nResult = 1;
            }
            else if (temp is MatrixValue)
            {
                nResult = ((MatrixValue)temp).Length;
            }
            else
            {
                throw new YAMPException("Bootstrap: The observable f has to return either a scalar or a matrix!");
            }

            var BootstrapObservable = new MatrixValue(numberOfBootstrapSamples, nResult);

            for (var i = 1; i <= numberOfBootstrapSamples; i++)
            {
                var BootstrapConfigs = new MatrixValue(nConfigs, nData);

                for (var j = 1; j <= nConfigs; j++)
                {
                    var idx = distribution.Next();

                    for (var k = 1; k <= nData; k++)
                    {
                        BootstrapConfigs[j, k] = cfgs[idx, k];
                    }
                }

                parameters = new ArgumentsValue(BootstrapConfigs);

                foreach (var m in P.Values)
                {
                    parameters.Insert(m);
                }

                temp = f.Perform(Context, parameters);

                if (temp is ScalarValue)
                {
                    BootstrapObservable[i] = (ScalarValue)temp;
                }
                else
                {
                    var m = (MatrixValue)temp;

                    for (var k = 1; k <= nResult; k++)
                    {
                        BootstrapObservable[i, k] = m[k];
                    }
                }
            }

            temp = YMath.Average(BootstrapObservable);

            for (var i = 1; i <= numberOfBootstrapSamples; i++)
            {
                if (temp is ScalarValue)
                {
                    BootstrapObservable[i] -= temp as ScalarValue;
                    BootstrapObservable[i] *= BootstrapObservable[i];
                }
                else
                {
                    var T = temp as MatrixValue;

                    for (var k = 1; k <= nResult; k++)
                    {
                        BootstrapObservable[i, k] -= T[k];
                        BootstrapObservable[i, k] *= BootstrapObservable[i, k];
                    }
                }
            }

            var error = YMath.Average(BootstrapObservable);
            var sqrt = new SqrtFunction();
            error = sqrt.Perform(error);
            var result = new MatrixValue(2, nResult);

            if (temp is ScalarValue)
            {
                result[1] = (ScalarValue)temp;
                result[2] = (ScalarValue)error;
            }
            else
            {
                var T = (MatrixValue)temp;
                var E = (MatrixValue)error;

                for (var k = 1; k <= nResult; k++)
                {
                    result[1, k] = T[k];
                    result[2, k] = E[k];
                }
            }

            return result;
        }
Пример #23
0
 public SetValue Function(SetValue set1, ArgumentsValue args)
 {
     return(SetValue.TExceptXor(set1, args));
 }
Пример #24
0
        void SetPerform(String name, String[] arguments, Expression body)
        {
            _perform = (context, argument) =>
            {
                var symbols = new Dictionary<String, Value>();
                var av = new ArgumentsValue().Append(argument);

                if (av.Length != arguments.Length)
                {
                    throw new YAMPArgumentNumberException(name, av.Length, arguments.Length);
                }

                for (var i = 0; i < arguments.Length; i++)
                {
                    symbols.Add(arguments[i], av.Values[i].Copy());
                }

                return body.Interpret(symbols);
            };
        }
Пример #25
0
 public SetValue Function(SetValue set1, ArgumentsValue args)
 {
     return SetValue.TIntersect(set1, args);
 }
Пример #26
0
 public SetValue Function(SetValue set1, ArgumentsValue args)
 {
     return SetValue.TUnion(set1, args);
 }
Пример #27
0
 public SetValue Function(SetValue set1, ArgumentsValue args)
 {
     return(SetValue.TIntersect(set1, args));
 }