public IEnumerable<IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters, params IVariable[] arguments)
        {
            if (!SupportsOperation(type, parameters, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
            var decomposition = milpManager.CompositeOperation(CompositeOperationType.Decomposition, new DecompositionParameters { Base = 2 }, arguments);
            if (arguments[0].IsConstant())
            {
                return decomposition;
            }

            return decomposition.Zip(Enumerable.Range(0, milpManager.IntegerWidth), (v, index) =>
            {
                v.Expression = $"unsignedMagnitudeDecomposition(bit: {index}, {arguments[0].FullExpression()})";
                return v;
            });
        }
 public IEnumerable<IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters, params IVariable[] arguments)
 {
     if (!SupportsOperation(type, parameters, arguments)) throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
     if (arguments.All(a => a.IsConstant()))
     {
         return arguments.OrderBy(a => a.ConstantValue.Value);
     }
     var results = milpManager.CompositeOperation(CompositeOperationType.NthElements,
         new NthElementsParameters {Indexes = Enumerable.Range(0, arguments.Length).Select(milpManager.FromConstant).ToArray()},
         arguments).ToArray();
     for (int i = 0; i < results.Length; ++i)
     {
         results[i].Expression = $"selectionSort(position: {i+1}, {string.Join(",", arguments.Select(a => a.FullExpression()).ToArray())})";
     }
     return results;
 }
Esempio n. 3
0
        public IEnumerable <IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters, params IVariable[] arguments)
        {
            if (!SupportsOperation(type, parameters, arguments))
            {
                throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
            }
            var decomposition = milpManager.CompositeOperation(CompositeOperationType.Decomposition, new DecompositionParameters {
                Base = 2
            }, arguments);

            if (arguments[0].IsConstant())
            {
                return(decomposition);
            }

            return(decomposition.Zip(Enumerable.Range(0, milpManager.IntegerWidth), (v, index) =>
            {
                v.Expression = $"unsignedMagnitudeDecomposition(bit: {index}, {arguments[0].FullExpression()})";
                return v;
            }));
        }
Esempio n. 4
0
        public IEnumerable <IVariable> Calculate(IMilpManager milpManager, CompositeOperationType type, ICompositeOperationParameters parameters, params IVariable[] arguments)
        {
            if (!SupportsOperation(type, parameters, arguments))
            {
                throw new NotSupportedException(SolverUtilities.FormatUnsupportedMessage(type, parameters, arguments));
            }
            if (arguments.All(a => a.IsConstant()))
            {
                return(arguments.OrderBy(a => a.ConstantValue.Value));
            }
            var results = milpManager.CompositeOperation(CompositeOperationType.NthElements,
                                                         new NthElementsParameters {
                Indexes = Enumerable.Range(0, arguments.Length).Select(milpManager.FromConstant).ToArray()
            },
                                                         arguments).ToArray();

            for (int i = 0; i < results.Length; ++i)
            {
                results[i].Expression = $"selectionSort(position: {i+1}, {string.Join(",", arguments.Select(a => a.FullExpression()).ToArray())})";
            }
            return(results);
        }