public IS2 Calculate(
     IS2ParameterElementFactory S2ParameterElementFactory,
     IS2Factory S2Factory,
     Id1 d1,
     Id2 d2,
     Ir r,
     It t,
     Ird1d2 rd1d2,
     IW W,
     Ix x,
     IΔ Δ)
 {
     return(S2Factory.Create(
                rd1d2.Value
                .Where(i => i.d1IndexElement.Value.Value.Value != i.d2IndexElement.Value.Value.Value)
                // rd1d2t1
                .SelectMany(b => t.GetNthElementsAt(
                                b.d1IndexElement.Value.Value.Value,
                                t.GetT() - W.Value.Value.Value + b.d1IndexElement.Value.Value.Value,
                                W.Value.Value.Value),
                            (a, b) => Tuple.Create(a.rIndexElement, a.d1IndexElement, a.d2IndexElement, b))
                // rd1d2t1t2
                .SelectMany(b => t.GetNthElementsAt(
                                b.Item3.Value.Value.Value,
                                t.GetT() - W.Value.Value.Value + b.Item3.Value.Value.Value,
                                W.Value.Value.Value),
                            (a, b) => Tuple.Create(a.Item1, a.Item2, a.Item3, a.Item4, b))
                .Select(
                    i => Tuple.Create(
                        i.Item1,
                        i.Item2,
                        i.Item3,
                        i.Item4,
                        i.Item5,
                        // x(j, r, t)
                        x.Value
                        .Where(j => j.Value.Value.Value)
                        .Select(j => Tuple.Create(
                                    Δ.GetSurgicalSpecialtyOfSurgeon(j.sIndexElement),
                                    j.rIndexElement,
                                    j.tIndexElement))
                        .Where(j => j.Item2 == i.Item1)
                        .Select(j => j.Item1)
                        .Distinct()
                        .Count()))
                .Where(i => i.Item6 == 1)
                .Select(i => S2ParameterElementFactory
                        .Create(
                            i.Item1,
                            i.Item2,
                            i.Item3))
                .ToImmutableList()));
 }
Beispiel #2
0
 public Iδ4 Calculate(
     Iδ4ParameterElementFactory δ4ParameterElementFactory,
     Iδ4Factory δ4Factory,
     Iδ4ParameterElementCalculation δ4ParameterElementCalculation,
     Isrd srd,
     It t,
     IW W,
     Iδ3 δ3,
     Iγ γ)
 {
     return(δ4Factory.Create(
                srd.Value
                .SelectMany(b =>
                            t.GetNthElementsAt(
                                b.dIndexElement.Value.Value.Value,
                                t.GetT() - W.Value.Value.Value + b.dIndexElement.Value.Value.Value,
                                W.Value.Value.Value),
                            (a, b) => Tuple.Create(a.sIndexElement, a.rIndexElement, a.dIndexElement, b))
                .Select(x =>
                        δ4ParameterElementCalculation.Calculate(
                            δ4ParameterElementFactory,
                            x.Item3,
                            x.Item2,
                            x.Item1,
                            x.Item4,
                            t,
                            W,
                            γ,
                            δ3))
                .ToImmutableList()));
 }
Beispiel #3
0
        public Constraints5LConstraintElement(
            IdIndexElement dIndexElement,
            IrIndexElement rIndexElement,
            IsIndexElement sIndexElement,
            ItIndexElement tIndexElement,
            It t,
            IW W,
            Iδ1 δ1,
            Iδ4 δ4,
            Ix x)
        {
            int LHS = δ1.GetElementAtAsint(
                sIndexElement,
                rIndexElement,
                dIndexElement);

            OPTANO.Modeling.Optimization.Expression RHS = OPTANO.Modeling.Optimization.Expression.Sum(
                t.GetNthElementsAt(
                    tIndexElement.Key,
                    tIndexElement.Key
                    +
                    (δ4.GetElementAtAsint(
                         sIndexElement,
                         rIndexElement,
                         dIndexElement,
                         tIndexElement)
                     - 1)
                    *
                    W.Value.Value.Value,
                    W.Value.Value.Value)
                .Select(
                    y => x.Value[sIndexElement, rIndexElement, y]));

            this.Value = LHS <= RHS;
        }
Beispiel #4
0
        public Iδ4ParameterElement Calculate(
            Iδ4ParameterElementFactory δ4ParameterElementFactory,
            IdIndexElement dIndexElement,
            IrIndexElement rIndexElement,
            IsIndexElement sIndexElement,
            ItIndexElement tIndexElement,
            It t,
            IW W,
            Iγ γ,
            Iδ3 δ3)
        {
            Iδ4ParameterElement δ4ParameterElement = null;

            int γSum = 0;

            int δ3Asint = δ3.GetElementAtAsint(
                sIndexElement,
                rIndexElement,
                dIndexElement);

            if (δ3Asint == 0)
            {
                δ4ParameterElement = δ4ParameterElementFactory.Create(
                    sIndexElement,
                    rIndexElement,
                    dIndexElement,
                    tIndexElement,
                    1);
            }
            else
            {
                int δ4 = 1;

                do
                {
                    γSum = t.GetNthElementsAt(
                        dIndexElement.Value.Value.Value,
                        dIndexElement.Value.Value.Value + (δ4 - 1) * W.Value.Value.Value,
                        W.Value.Value.Value)
                           .Select(x => γ.GetElementAtAsint(
                                       rIndexElement,
                                       t.GetElementAt(x.Key)))
                           .Sum();

                    δ4 = δ4 + 1;
                } while (γSum < δ3Asint);

                if (γSum == δ3Asint)
                {
                    δ4ParameterElement = δ4ParameterElementFactory.Create(
                        sIndexElement,
                        rIndexElement,
                        dIndexElement,
                        tIndexElement,
                        δ4 - 1);     // Subtract 1 to account for last iteration of the do-while loop
                }
            }

            return(δ4ParameterElement);
        }
Beispiel #5
0
        public Iδ3ParameterElement Calculate(
            Iδ3ParameterElementFactory δ3ParameterElementFactory,
            IdIndexElement dIndexElement,
            IrIndexElement rIndexElement,
            IsIndexElement sIndexElement,
            It t,
            IW W,
            Iβ β,
            Iγ γ)
        {
            int value = 0;

            int γSum = t.GetNthElementsAt(
                dIndexElement.Value.Value.Value,
                t.GetT() - W.Value.Value.Value + dIndexElement.Value.Value.Value,
                W.Value.Value.Value)
                       .Select(
                y => γ.GetElementAtAsint(
                    rIndexElement,
                    y))
                       .Sum();

            int βAsint = β.GetElementAtAsint(
                sIndexElement,
                rIndexElement,
                dIndexElement);

            if (βAsint > 0)
            {
                // Case (i)
                if ((γSum % βAsint) == 0)
                {
                    value = γSum / βAsint;
                }
                else if ((γSum % βAsint) != 0)
                {
                    // Case (ii)
                    if (βAsint < (γSum / 2))
                    {
                        value =
                            (int)Math.Floor(
                                (decimal)(γSum / βAsint));
                    }
                    // Case (iii)
                    else if ((βAsint > (γSum / 2)) && (βAsint < γSum))
                    {
                        value =
                            (int)Math.Floor(
                                (decimal)(γSum / (γSum - βAsint)));
                    }
                }
            }

            return(δ3ParameterElementFactory.Create(
                       sIndexElement,
                       rIndexElement,
                       dIndexElement,
                       value));
        }
        public Constraints7ConstraintElement(
            IdIndexElement dIndexElement,
            IrIndexElement rIndexElement,
            IsIndexElement sIndexElement,
            It t,
            IW W,
            Ix x,
            Iβ β)
        {
            OPTANO.Modeling.Optimization.Expression LHS = OPTANO.Modeling.Optimization.Expression.Sum(
                t.GetNthElementsAt(
                    dIndexElement.Value.Value.Value,
                    t.GetT() - W.Value.Value.Value + dIndexElement.Value.Value.Value,
                    W.Value.Value.Value)
                .Select(
                    y => x.Value[sIndexElement, rIndexElement, y]));

            OPTANO.Modeling.Optimization.Expression RHS = β.Value[sIndexElement, rIndexElement, dIndexElement];

            this.Value = LHS == RHS;
        }
Beispiel #7
0
        public Constraints1ConstraintElement(
            IdIndexElement dIndexElement,
            IrIndexElement rIndexElement,
            IsIndexElement sIndexElement,
            It t,
            IW W,
            Iβ β,
            Ix x)
        {
            Expression LHS = Expression.Sum(
                t.GetNthElementsAt(
                    dIndexElement.Value.Value.Value,
                    t.GetT() - W.Value.Value.Value + dIndexElement.Value.Value.Value,
                    W.Value.Value.Value)
                .Select(
                    y => x.Value[sIndexElement, rIndexElement, y]));

            int RHS = β.GetElementAtAsint(
                sIndexElement,
                rIndexElement,
                dIndexElement);

            this.Value = LHS == RHS;
        }