コード例 #1
0
        /// <summary>
        /// Shuffles a list based on the Fisher-Yates shuffle.
        /// </summary>
        /// <typeparam name="T">A generic type.</typeparam>
        /// <param name="list">The list to be shuffled.</param>
        public static void Shuffle <T>(this IList <T> list)
        {
            int n = list.Count;

            while (n > 1)
            {
                n--;
                int k     = GenRandNumbers.Next(n + 1);
                T   value = list[k];
                list[k] = list[n];
                list[n] = value;
            }
        }
コード例 #2
0
        /// <summary>
        /// Creates a cost system. Assigns resources to pools and selects
        /// drivers for each pool.
        /// </summary>
        /// <param name="ip">An input parameters object.</param>
        /// <param name="firm">The firm upon which this cost system is based.</param>
        /// <param name="a">The number of activity cost pools to form.</param>
        /// <param name="p">A flag indicating method for assigning resources to cost pools.
        /// See input file cheat sheet for details.</param>
        /// <param name="r">A flag indicating which resources in the pools
        /// will be used to form drivers. See input file cheat sheet for details.</param>
        public CostSys(
            InputParameters ip,
            Firm firm,
            int a,
            int p,
            int r)
        {
            this.firm = firm;
            RowVector RCC = firm.Initial_RCC;

            int[]           RANK = firm.Initial_RANK;
            SymmetricMatrix CORR = firm.PEARSONCORR;

            this.a = a;
            this.p = p;
            this.r = r;

            if (a != 1)
            {
                #region Code shared in flowchart 6.1, 6.2, and 6.3

                // Segregate resources into big ones that will each
                // seed a pool, and miscellaneous resources.
                // The first (a-1) resources get their own pools.
                List <int> bigResources  = RANK.Take(a - 1).ToList();
                List <int> miscResources = RANK.Skip(a - 1).ToList();

                // Create the set B and initialize the first
                // elements with the big pool resources.

                // Seeding big resources
                // Take each resource from bigPools, ane make it into a list
                // of length 1. Convert to an array of lists, and assign to B.
                B = bigResources.Select(elem => new List <int> {
                    elem
                }).ToArray();

                // Increase the length by 1, to make room for the miscellaneous
                // pool.
                Array.Resize(ref B, B.Length + 1);
                B[B.Length - 1] = new List <int>();

                #endregion

                // p == 0:
                // Seed (a-1) pools with the largest (a-1) resources.
                // All remaining resources assigned to miscellaneous pool
                if (p == 0)
                {
                    #region Flowchart 6.1

                    B[a - 1] = new List <int>(miscResources);

                    #endregion
                }
                // p == 1:
                // Seed acp-1 pools based on size. Check to see
                // the highest correlation for the remaining resources. Assign the
                // unassigned resource with the highest correlation to
                // the relevant ACP. Check to see if the value of remaining
                // ACP > MISCPOOLSIZE. If so, continue to find the next highest
                // correlation, assign and check. When remaining value < 20%,
                // then pool everything into misc.
                else if (p == 1)
                {
                    #region Flowchart 6.2

                    // This query iterates over miscResources. For each one, it
                    // computes the correlation with every bigResource, and forms
                    // a record {smallResourceIndex, index of big pool (in B), correlation }.
                    // Order this list of records in descending order and keep the first one.
                    // This first one is the pool to which the small resources will be allocated
                    // if the correlation is sufficiently high.
                    var query =
                        miscResources.Select(smallRes => bigResources.Select((bigRes, i) => new { smallRes, BigPoolNum = i, correl = CORR[bigRes, smallRes] }).OrderByDescending(x => x.correl).First());
                    // Order the small resources by correlation with big resources. Thus,
                    // if resource 7 is most correlated with big pool resource 0 (92%),
                    // and resource 12 is most correlated with big pool resource 1 (83%),
                    // 7 will be ahead of 12 in myArray.
                    var myArray = query.OrderByDescending(x => x.correl).ToArray();

                    // The following block makes sure that at least one nonzero
                    // resource is allocated to the last pool. The only time this
                    // fails is if all miscellaneous resources are zero.
                    int lastResourceToAllocate;
                    {
                        // Convert each record in myArray to the value of the resource
                        // cost pool represented by that resource
                        var moo = myArray.Select(x => RCC[x.smallRes]);
                        // Convert each element of moo to the value of the remaining
                        // resources in the array at this point.
                        var moo2 = moo.Select((_, i) => moo.Skip(i).Sum());

                        List <double> ld = moo2.ToList();
                        // If the list contains a 0, that means there are one or
                        // more zero resources. Find the index of the first one,
                        // or if there isn't one, use the end of the array.
                        if (ld.Contains(0.0))
                        {
                            lastResourceToAllocate = ld.IndexOf(0.0) - 1;
                        }
                        else
                        {
                            lastResourceToAllocate = myArray.Length;
                        }
                    }

                    double TR = RCC.Sum();
                    double notYetAllocated = miscResources.Aggregate(0.0, (acc, indx) => acc + RCC[indx]);
                    bool   cutoffReached   = (notYetAllocated / TR) < ip.MISCPOOLSIZE;

                    for (int k = 0; (k < lastResourceToAllocate) && !cutoffReached; ++k)
                    {
                        var q = myArray[k];

                        if (q.correl >= ip.CC)
                        {
                            B[q.BigPoolNum].Add(q.smallRes);
                            miscResources.Remove(q.smallRes);
                        }
                        else
                        {
                            break;
                        }

                        notYetAllocated = miscResources.Aggregate(0.0, (acc, indx) => acc + RCC[indx]);
                        cutoffReached   = (notYetAllocated / TR) < ip.MISCPOOLSIZE;
                    }

                    // Check if there is anything left in miscResources
                    // If yes, throw it in the miscellaneous pool (B.Last()).
                    if (miscResources.Count > 0)
                    {
                        B.Last().AddRange(miscResources);
                    }
                    // If not, remove the last allocated resource (myArray.Last())
                    // from the pool to which it was allocated, and place it in the
                    // miscellaneous pool.
                    else
                    {
                        var q = myArray.Last();
                        B[q.BigPoolNum].Remove(q.smallRes);
                        B.Last().Add(q.smallRes);
                    }

                    #endregion
                }
                // p == 2:
                // Seed each of the (a-1) cost pools with the largest resources.
                // Allocate the remaining resources to the (a-1) pools at random.
                // However, ensure that enough resources are in the last pool.
                // The fraction of resources in the last pool is MISCPOOLSIZE.
                else if (p == 2)
                {
                    #region Flowchart 6.3

                    double TR = RCC.Sum();
                    // Magnitude of resources not yet allocated
                    double notYetAllocated = miscResources.Aggregate(0.0, (acc, indx) => acc + RCC[indx]);
                    // Fraction of resources not yet allocated
                    double miscPoolPrct = notYetAllocated / TR;

                    // Logic: Check if the fraction of resources in
                    // miscResources is greater than the cap (ip.MISCPOOLSIZE).
                    // If yes, take the first resource from miscResources
                    // and put it in one of the big pools, chosen at random.
                    // If the fraction of resources in miscResources is still
                    // greater than the cap, repeat the loop. Otherwise,
                    // stop and put the remaining resources in the last pool.
                    //
                    // Also stop under the following condition. Assume the head
                    // of the miscResources list is allocated. Is the value of the
                    // remaining resources in miscResources (the tail) greater than
                    // zero? If not, stop. There has to be at least one non-zero
                    // resource in the last pool.
                    while (
                        (miscPoolPrct > ip.MISCPOOLSIZE) &&
                        (miscResources.Skip(1).Aggregate(0.0, (acc, indx) => acc + RCC[indx]) > 0.0)
                        )
                    {
                        // Pick a pool at random to get the next resource
                        int poolIndx = (int)GenRandNumbers.GenUniformInt(0, a - 2);
                        B[poolIndx].Add(miscResources.First());
                        miscResources.RemoveAt(0);

                        notYetAllocated = miscResources.Aggregate(0.0, (acc, indx) => acc + RCC[indx]);
                        miscPoolPrct    = notYetAllocated / TR;
                    }

                    B.Last().AddRange(miscResources);

                    #endregion
                }
                // p == 3:
                // Seed the first pool with the largest resource.
                // Iterate over the other pools. For each pool, select a seed resource:
                // This is the largest of the remaining, unassigned resources, and
                // assign it to the pool.
                // Form a correlation vector (a list), which is the correlation
                // of each resource in remainingResources with the seed resource.
                // If the highest correlation is greater than ip.CC, there are
                // enough remaining resources to fill the remaining pools, and
                // satisfy the constraint about the miscellaneous pool size,
                //assign resource with the highest correlation to the current pool.
                // Once there are just as many resources remaining as there are pools,
                // assign one resource to each remaining pool.
                else if (p == 3)
                {
                    #region Flowchart 6.4

                    // Initialize B
                    for (int i = 0; i < B.Length; ++i)
                    {
                        B[i] = new List <int>();
                    }

                    // Seed the first pool with the largest resource
                    B[0].Add(RANK[0]);
                    List <int> remainingResources = RANK.Skip(1).ToList();

                    // Assign all zero resources to the last (miscellaneous) pool.
                    // That way, each of the remaining pools is guaranteed to have
                    // a nonzero resource.
                    // This only works if there are at least as many nonzero resources
                    // as there are pools. If not, then skip this step so that each
                    // pool has at least one resource.
                    int numZeroResources = remainingResources.Count(res => RCC[res] == 0.0);
                    if (RCC.Dimension - numZeroResources >= B.Length)
                    {
                        while (RCC[remainingResources.Last()] == 0.0)
                        {
                            B.Last().Add(remainingResources.Last());
                            remainingResources.RemoveAt(remainingResources.Count - 1);
                        }
                    }

                    // Iterate over the pools. For each pool, select a seed resource,
                    // which is the first resource assigned to the pool.
                    // Form a correlation vector (a list), which is the correlation
                    // of each resource in remainingResources with the seed resource.
                    // While max of the list is greater than ip.CC, and while
                    // the other conditions are satisfied, assign resource with the
                    // maximum correlation to the current pool.
                    // Once condition 2 is no longer true, there are just as many
                    // resources remaining as there are pools. The loop then assigns
                    // one resource to each remaining pool.
                    // Once condition 3 is no longer true, it assigns one resource
                    // to each pool, and all the remaining resources to the last pool.
                    for (int currentPool = 0; currentPool < B.Length - 1; ++currentPool)
                    {
                        int seedResource    = B[currentPool].First();
                        int poolsToBeFilled = B.Length - (currentPool + 1);

                        List <double> correlations = remainingResources.Select(res => CORR[res, seedResource]).ToList();
                        bool          cond1        = correlations.Max() > ip.CC;
                        bool          cond2        = remainingResources.Count > poolsToBeFilled;

                        // Magnitude of resources not yet allocated
                        double notYetAllocated = remainingResources.Aggregate(0.0, (acc, indx) => acc + RCC[indx]);
                        // Fraction of resources not yet allocated
                        double TR           = RCC.Sum();
                        double miscPoolPrct = notYetAllocated / TR;
                        bool   cond3        = miscPoolPrct > ip.MISCPOOLSIZE;

                        while (cond1 && cond2 && cond3)
                        {
                            // Find the index of the resource with the maximum correlation
                            // with the seed resource
                            double maxCorr     = correlations.Max();
                            int    maxCorrIndx = remainingResources[correlations.IndexOf(maxCorr)];

                            // Add it to the current pool
                            B[currentPool].Add(maxCorrIndx);

                            // Remove it from the remainingResources list
                            remainingResources.RemoveAt(correlations.IndexOf(maxCorr));
                            correlations.Remove(maxCorr);

                            // Recompute loop termination conditions
                            cond1           = correlations.Max() > ip.CC;
                            cond2           = remainingResources.Count > poolsToBeFilled;
                            notYetAllocated = remainingResources.Aggregate(0.0, (acc, indx) => acc + RCC[indx]);
                            miscPoolPrct    = notYetAllocated / TR;
                            cond3           = miscPoolPrct > ip.MISCPOOLSIZE;
                        }

                        B[currentPool + 1].Add(remainingResources[0]);
                        remainingResources.RemoveAt(0);
                    }

                    B.Last().AddRange(remainingResources);

                    #endregion
                }
                else
                {
                    throw new ApplicationException("Invalid value of p.");
                }
            }
            else
            {
                #region Flowchart 6.5

                B = new List <int>[] { new List <int>(RANK) };

                #endregion
            }

            // The fraction of RCC that is in the miscellaneous (last)
            // activity cost pool.
            double miscPoolSize = B.Last().Aggregate(0.0, (acc, i) => acc + RCC[i]) / RCC.Sum();

            #region Flowchart 6.5 -- Choosing drivers

            // For each element of B, which is a list of resource indexes,
            // sort it in descending order by pool size (RCC[element]).
            // Technically, this is unnecessary, since elements should have
            // been added to the lists in B in descending order. But instead
            // of assuming that, since that could change in the future,
            // I am going to re-sort. Heck, it's only one line of code,
            // plus this essay of a comment that I just wrote.
            {
                var query = B.Select(list => list.OrderByDescending(indx => RCC[indx]));

                int numToTake;
                if (r == 0)
                {
                    numToTake = 1;
                }
                else if (r == 1)
                {
                    numToTake = ip.NUM;
                }
                else
                {
                    throw new ApplicationException("Invalid value of r in FalseSys.cs.");
                }

                // This iterates over every list in query, and replaces that list
                // with a list containing only the first numToTake elements.
                var drivers = query.Select(list => list.Take(numToTake).ToList());
                D = drivers.ToArray();
            }
            #endregion
        }
コード例 #3
0
ファイル: Firm.cs プロジェクト: vanand74/CostSystemSim
        /// <summary>
        /// Implements step 5.3 of the flowchart: Generates a [1 x RCP] vector of
        /// total resource costs by resource.
        /// </summary>
        /// <param name="ip">An input parameters object.</param>
        private RowVector GenRCC(InputParameters ip)
        {
            bool          throwAway;
            int           numThrows = 0;
            List <double> rcc;

            // repeat the following loop until a suitable vector
            // RCC is generated.
            do
            {
                /* -------------------------------- */
                // Flowchart 5.4(b)

                // Calculate total resource cost of first DISP1 resources
                double topTR = G * ip.TR;
                // Calculate minimum allowable resource cost in first
                // DISP1 resources
                double rmin = (1.0 - G) * ip.TR / (ip.RCP - ip.DISP1);
                // The following is an upward adjustment of rmin.
                // Without this, the values of the resources in the
                // remaining resources have too little variance.
                // It checks how much room there is to adjust rmin,
                // and takes 2.5% of that room. The 2.5% was determined
                // through trial and error.
                double maxValOfLargestElem = topTR - ((ip.DISP1 - 1.0) * rmin);
                rmin += (maxValOfLargestElem - rmin) * 0.025;

                /* -------------------------------- */
                // Flowchart 5.4(c)

                // Generate the first DISP1 random numbers
                List <double> temp1 = new List <double>();
                for (int i = 1; i <= ip.DISP1 - 1; ++i)
                {
                    double rmax = (topTR - temp1.Sum()) - ((ip.DISP1 - i) * rmin);
                    if (rmax < rmin)
                    {
                        throw new ApplicationException("rmax less than rmin");
                    }
                    double ri = GenRandNumbers.GenUniformDbl(rmin, rmax);
                    temp1.Add(ri);
                }
                // The final element is computed to ensure that the total
                // in temp1 is topTR
                temp1.Add(topTR - temp1.Sum());
                // Move the biggest resource to the front
                double temp1Max = temp1.Max();
                if (!temp1.Remove(temp1Max))
                {
                    throw new ApplicationException("Could not remove largest element.");
                }
                temp1.Insert(0, temp1Max);

                // SOME CHECKS ON THE NUMBERS
                if (Math.Abs(temp1.Sum() - ip.TR * G) > 1.0)
                {
                    throw new ApplicationException("Sum of first DISP1 resources not correct.");
                }
                if (temp1.Min() < (1 - G) * ip.TR / (ip.RCP - ip.DISP1))
                {
                    throw new ApplicationException("Min element too small.");
                }

                /* -------------------------------- */
                // Flowchart 5.4(d)

                List <double> temp2 = new List <double>();
                for (int i = 0; i < ip.RCP - ip.DISP1; ++i)
                {
                    temp2.Add(GenRandNumbers.GenUniformDbl(0.05, 0.95));
                }
                temp2.Normalize();
                temp2.MultiplyBy((1.0 - G) * ip.TR);

                double temp1Min = temp1.Min();
                while (temp2.Max() - temp1.Min() > 1.0)
                {
                    // Sort the list in descending order
                    temp2.Sort();
                    temp2.Reverse();

                    for (int i = 0; i < temp2.Count / 2; ++i)
                    {
                        double overage = Math.Max(temp2[i] - temp1Min, 0.0);
                        temp2[i] -= overage;
                        temp2[temp2.Count - 1 - i] += overage;
                    }
                }
                temp2.Shuffle();

                // SOME CHECKS
                if (Math.Abs(temp2.Sum() - ip.TR * (1.0 - G)) > 1.0)
                {
                    throw new ApplicationException("Sum of small resources not correct.");
                }

                /* -------------------------------- */
                // Flowchart 5.4(e)
                rcc = new List <double>(ip.RCP);
                rcc.AddRange(temp1);
                rcc.AddRange(temp2);

                /* -------------------------------- */
                // Flowchart 5.4(f)
                throwAway = rcc.Exists(x => x < 1.0);

                // SOME CHECKS
                if (rcc.Min() < 0.0)
                {
                    throw new ApplicationException("Negative element in RCC.");
                }

                if (throwAway)
                {
                    ++numThrows;
                }
            } while (throwAway);

            return(new RowVector(rcc));
        }
コード例 #4
0
ファイル: Firm.cs プロジェクト: vanand74/CostSystemSim
        /// <summary>
        /// Randomly generates a firm object (production technology and output market parameters).
        /// </summary>
        /// <param name="ip">A pointer to the collection of input parameters.</param>
        /// <param name="FirmID">Unique identifier for this firm (run number)</param>
        public Firm(InputParameters ip, int FirmID)
        {
            // Choose random values for DISP2 (the top DISP1 resources
            // account for DISP2 percent of total resource costs), and
            // density (sparsity) of resource consumption pattern matrix
            this.g = GenRandNumbers.GenUniformDbl(ip.DISP2_MIN, ip.DISP2_MAX);
            this.d = GenRandNumbers.GenUniformDbl(ip.DNS_MIN, ip.DNS_MAX);

            // Generate the true product margins and the true, optimal
            // decision vector. Keep generating new margins until there
            // is at least one product in the optimal mix.
            RowVector MAR, DECT0;

            do
            {
                MAR   = this.GenMargins(ip);
                DECT0 = MAR.Map(x => (x < 1.0) ? 0.0 : 1.0);
            } while (DECT0.TrueForAll(x => x == 0.0));

            // Generate vector of maximum production quantities
            this.mxq = this.GenMXQ(ip);
            // And associated vector of optimal production quantities
            ColumnVector QT = mxq.ewMultiply(DECT0);

            // Flowchart 5.1 - Create resource consumption pattern matrix
            this.res_cons_pat = GenResConsPat(ip);

            // Flowchart 5.2 - Compute TRU
            // Calculate vector of total units of resource
            // consumption, by product
            ColumnVector TRU = this.CalcResConsumption(QT);

            // Flowchart 5.3 - Compute MAXRU
            // Calculate resource consumption under the assumption
            // that all products are produced at maximum quantity
            ColumnVector MAXRU = this.CalcResConsumption(mxq);

            RowVector RCC, PC_B, RCCN;
            double    TCT0;

            #region Flowchart 5.4 - Generate RCC, RCU, and RCCN

            /* -------------------------------- */
            // Flowchart 5.4(a)-(g)

            // Generate vector of total resource costs (RCC)
            RCC = GenRCC(ip);

            /* -------------------------------- */
            // Flowchart 5.4(h)

            // Now generate unit resource costs (RCU) by doing element-wise
            // division of RCC by MAXRU
            this.rcu = RCC.Map((x, i) => x / MAXRU[i]);

            /* -------------------------------- */
            // Flowchart 5.4(i)

            // Compute new RCC vector (RCCN) based on unit resource
            // costs (RCU) and true unit resource consumption (TRU)
            RCCN = this.rcu.ewMultiply(TRU);
            // Check to see if the first resource (RCCN[0]) is the largest.
            // If not, increase RCU[0] by just enough to make it so.
            if (RCCN[0] < RCCN.Skip(1).Max() + 1)
            {
                RCCN[0]     = Math.Ceiling(RCCN.Max()) + 1.0;
                this.rcu[0] = RCCN[0] / TRU[0];
            }

            #endregion

            // Flowchart 5.5 - Calculate PC_B
            // Calculate true unit product costs
            PC_B = this.CalcTrueProductCosts();

            // Flowchart 5.6 - Compute total costs TCT0
            // Compute total costs
            TCT0 = this.CalcTotCosts(QT);

            // Flowchart 5.7 - Rename RCCN to RCC
            RCC         = RCCN;
            initial_rcc = RCC;

            #region Flowchart 5.8 - Calculate SP, TRV0, PROFITT0

            // Calculate product selling prices, total revenue, and profit
            this.sp = PC_B.ewMultiply(MAR);
            double TRV0 = this.sp * QT;
            this.profitt0 = TRV0 - TCT0;

            #endregion

            // 5.9(a) Create RANK vector
            // Note: this method provides a stable sort. It's important to use a stable sort.
            // LOOKUP IN VERSION.TXT WHY IT'S IMPORTANT TO USE A STABLE SORT HERE.
            initial_rank = Enumerable.Range(0, RCC.Dimension).OrderByDescending(i => RCC[i]).ToArray();

            #region Flowchart 5.9(b) - Create RES_CONS_PAT_PRCT

            this.res_cons_pat_prct = new RectangularMatrix(ip.RCP, ip.CO);

            for (int r = 0; r < this.res_cons_pat.RowCount; ++r)
            {
                RowVector rv = this.res_cons_pat.Row(r);
                if (TRU[r] != 0.0)
                {
                    rv = rv.Map((alt_ij, col) => alt_ij * QT[col] / TRU[r]);
                    if (Math.Abs(rv.Sum() - 1.0) > 0.01)
                    {
                        throw new ApplicationException("Sum of row of RES_CONS_PAT_PRCT not equal to 1.");
                    }
                }
                else
                {
                    rv = rv.Map(alt_ij => 0.0);
                }

                this.res_cons_pat_prct.CopyRowInto(rv, r);
            }

            #endregion

            #region Flowchart 5.9(c) - Create correlation matrix
            // Create correlation matrix for rows of RES_CONS_PAT_PRCT
            MultivariateSample mvs = new MultivariateSample(ip.RCP);
            for (int c = 0; c < this.res_cons_pat_prct.ColumnCount; ++c)
            {
                mvs.Add(this.res_cons_pat_prct.Column(c));
            }

            this.pearsoncorr = new SymmetricMatrix(ip.RCP);

            for (int i = 0; i < mvs.Dimension; ++i)
            {
                for (int j = i; j < mvs.Dimension; ++j)
                {
                    //PearsonCorr[i, j] = mvs.PearsonRTest( i, j ).Statistic;
                    this.pearsoncorr[i, j] = mvs.TwoColumns(i, j).PearsonRTest().Statistic;
                }
            }

            #endregion

            // Flowchart 5.10 - Logging true system
            // Note: I'm deliberately passing copies of the fields MXQ, SP, etc.
            Output.LogFirm(
                ip, this, FirmID,
                MAR, DECT0,
                TRV0, TCT0, profitt0,
                RCC);
        }
コード例 #5
0
ファイル: Firm.cs プロジェクト: vanand74/CostSystemSim
 /// <summary>
 /// Generates a random vector of capacities (maximum production
 /// quantities). Each element is drawn from discrete U[10,40].
 /// </summary>
 /// <param name="ip">The current InputParameters object</param>
 /// <returns>A [CO x 1] vector, each element drawn from
 /// the *discrete* distribution U[10,40].</returns>
 private ColumnVector GenMXQ(InputParameters ip)
 {
     return(new ColumnVector(ip.CO).Map(x => GenRandNumbers.GenUniformInt(10, 40)));
 }
コード例 #6
0
ファイル: Firm.cs プロジェクト: vanand74/CostSystemSim
 /// <summary>
 /// Generates a vector of product margins. Each element is
 /// U[ip.MARLB, ip.MARUB]. Values less than (greater) than one indicate
 /// products that generate losses (profits).
 /// </summary>
 /// <param name="ip">The current InputParameters object</param>
 /// <returns>A [1 x CO] vector, each element drawn from
 /// the distribution U[ip.MARLB, ip.MARUB].</returns>
 private RowVector GenMargins(InputParameters ip)
 {
     return(new RowVector(ip.CO)
            .Map(x => GenRandNumbers.GenUniformDbl(ip.MARLB, ip.MARUB)));
 }
コード例 #7
0
ファイル: Firm.cs プロジェクト: vanand74/CostSystemSim
        /// <summary>
        /// Generates a resource consumption pattern matrix
        /// </summary>
        /// <param name="ip">The current InputParameters object</param>
        private RectangularMatrix GenResConsPat(InputParameters ip)
        {
            bool throwAway;
            int  numThrows = 0;

            RectangularMatrix outputMatrix;

            do
            {
                throwAway    = false;
                outputMatrix = new RectangularMatrix(ip.RCP, ip.CO);

                // Flowchart 5.1(a): Generate vector X
                RowVector X = GenRandNumbers.GenStdNormalVec(ip.CO);

                // The following code is used in both 5.1(b) and 5.1(c):
                RowVector[] Y = new RowVector[ip.RCP - 1];
                RowVector[] Z = new RowVector[Y.Length];

                for (int i = 0; i < Y.Length; ++i)
                {
                    Y[i] = GenRandNumbers.GenStdNormalVec(ip.CO);
                }

                // Flowchart 5.1(b): Generate (DISP1 - 1) vectors Y
                // Then create Z vectors based on X and Y
                double COR1 =
                    GenRandNumbers.GenUniformDbl(ip.COR1LB, ip.COR1UB);
                double sqrtConstant1 = Math.Sqrt(1 - COR1 * COR1);
                for (int i = 0; i < ip.DISP1 - 1; ++i)
                {
                    Z[i] = (COR1 * X) + (sqrtConstant1 * Y[i]);
                }

                // Flowchart 5.1(c): Generate (RCP - DISP1) vectors Y
                // Then create the remaining Z vectors based on X and Y
                double COR2 =
                    GenRandNumbers.GenUniformDbl(ip.COR2LB, ip.COR2UB);
                double sqrtConstant2 = Math.Sqrt(1 - COR2 * COR2);
                for (int i = ip.DISP1 - 1; i < Z.Length; ++i)
                {
                    Z[i] = (COR2 * X) + (sqrtConstant2 * Y[i]);
                }

                // Flowchart 5.1(d):
                // Take the absolute values of X and the Z's and
                // scale both by 10.0.
                X = X.Map(x => 10.0 * Math.Abs(x));
                for (int i = 0; i < Z.Length; ++i)
                {
                    Z[i] = Z[i].Map(z => 10.0 * Math.Abs(z));
                }

                // Round X and the Z's to integers
                X = X.Map(x => Math.Ceiling(x));
                for (int i = 0; i < Z.Length; ++i)
                {
                    Z[i] = Z[i].Map(z => Math.Ceiling(z));
                }

                // Flowchart 5.1(e):
                // Now punch out values in the Z's at random to make
                // the matrix sparse
                for (int i = 0; i < Z.Length; ++i)
                {
                    Z[i] = Z[i].Map(x => ((GenRandNumbers.GenUniformDbl() < D) ? x : 0.0));
                }

                // Flowchart 5.1(f):
                // Copy X into first row of outputMatrix.
                outputMatrix.CopyRowInto(X, 0);
                // Copy the Z's into the remaining rows of outputMatrix.
                for (int i = 0; i < Z.Length; ++i)
                {
                    outputMatrix.CopyRowInto(Z[i], i + 1);
                }

                // Ensure that the first row has no zeros
                // There is a very small probability of getting a zero with
                // the Ceiling function, but given that there are a finite
                // number of double-precision floating point numbers, it
                // is not impossible to get a 0.0.
                double[] firstRow = outputMatrix.Row(0).ToArray();

                if (Array.Exists(firstRow, x => x == 0.0))
                {
                    throwAway = true;
                    break;
                }

                // Ensure that each *row* has at least one non-zero entry
                for (int i = 0; i < outputMatrix.RowCount; ++i)
                {
                    double[] nextRow = outputMatrix.Row(i).ToArray();

                    if (Array.TrueForAll(nextRow, x => x == 0.0))
                    {
                        throwAway = true;
                        break;
                    }
                }

                // Ensure that each *column* has at least one non-zero entry
                // Technically, this check is redundant, as the first row, X,
                // is not supposed to have any zero entries. But just to be
                // on the safe side...
                for (int j = 0; j < outputMatrix.ColumnCount; ++j)
                {
                    double[] nextCol = outputMatrix.Column(j).ToArray();

                    if (Array.TrueForAll(nextCol, x => x == 0.0))
                    {
                        string s = "There is a column with all zeros. " +
                                   "That should not happen since the first row is " +
                                   "supposed to have no zeros.";
                        throw new ApplicationException(s);
                    }
                }

                if (throwAway)
                {
                    ++numThrows;
                }
            } while (throwAway);

            Console.WriteLine("RES_CONS_PAT: {0} Throw aways\n", numThrows);

            return(outputMatrix);
        }
コード例 #8
0
ファイル: Program.cs プロジェクト: vanand74/CostSystemSim
        static void Main(string[] args)
        {
            #region Console header

            DrawASCIIart();

            #endregion

            #region Read input file and create InputParameters object

            FileInfo inputFile = new FileInfo(Environment.CurrentDirectory + @"\input.txt");

            if (!inputFile.Exists)
            {
                Console.WriteLine("Could not find input file: \n{0}", inputFile.FullName);
                Console.WriteLine("Aborting. Press ENTER to end the program.");
                Console.ReadLine();
                return;
            }

            InputParameters ip = new InputParameters(inputFile);

            #endregion

            #region Make a copy of the input file

            // We found it helpful to make a copy of the input file every time we ran the
            // simulation. We stamp the copy's filename with the date and time so that
            // we know which results files correspond to which input file.
            DateTime dt = DateTime.Now;
            string   inputFileCopyName =
                String.Format(
                    "input {0:D2}-{1:D2}-{2:D4} {3:D2}h {4:D2}m {5:D2}s, seed {6:G}.txt",
                    dt.Month,
                    dt.Day,
                    dt.Year,
                    dt.Hour,
                    dt.Minute,
                    dt.Second,
                    GenRandNumbers.GetSeed()
                    );
            FileInfo inputFileCopy = new FileInfo(Environment.CurrentDirectory + @"\" + inputFileCopyName);
            inputFile.CopyTo(inputFileCopy.FullName, true);
            File.SetCreationTime(inputFileCopy.FullName, dt);
            File.SetLastWriteTime(inputFileCopy.FullName, dt);

            #endregion

            #region Create output files

            Output.CreateOutputFiles(ip);

            #endregion

            #region Generate Sample of Firms and their Cost Systems

            Firm[] sampleFirms = new Firm[ip.NUM_FIRMS];

            for (int firmID = 1; firmID <= ip.NUM_FIRMS; ++firmID)
            {
                Console.WriteLine(
                    "Starting firm {0:D3} of {1}",
                    firmID + 1, sampleFirms.Length
                    );

                Firm f = new Firm(ip, firmID);
                sampleFirms[firmID - 1] = f;

                for (int a_indx = 0; a_indx < ip.ACP.Count; ++a_indx)
                {
                    int a = ip.ACP[a_indx];

                    for (int p_indx = 0; p_indx < ip.PACP.Count; ++p_indx)
                    {
                        int p = ip.PACP[p_indx];

                        for (int r_indx = 0; r_indx < ip.PDR.Count; ++r_indx)
                        {
                            int r = ip.PDR[r_indx];

                            // Create a cost system
                            CostSys costsys = new CostSys(ip, f, a, p, r);
                            f.costSystems.Add(costsys);
                            int costSysID = f.costSystems.Count;
                            Output.LogCostSys(costsys, firmID, costSysID);

                            // Generate a starting decision for the cost system.
                            RowVector startingDecision;
                            if (ip.STARTMIX == 0)
                            {
                                startingDecision = f.CalcOptimalDecision();
                            }
                            else
                            {
                                var ones = Enumerable.Repeat(1.0, ip.CO).ToList();
                                startingDecision = new RowVector(ones);
                                for (int i = 0; i < startingDecision.Dimension; ++i)
                                {
                                    if (GenRandNumbers.GenUniformDbl() < ip.EXCLUDE)
                                    {
                                        startingDecision[i] = 0.0;
                                    }
                                }
                            }

                            /* Examine error in cost from implementing this decision.
                             * Assume the firm implements the decision startingDecision. Upon
                             * doing so, it will observe total resource consumption. It will then
                             * allocate resources to cost pools, as per the B parameter of the cost
                             * system, choose drivers as per the D parameter of the cost system,
                             * and then allocate resources to cost objects and compute reported costs.
                             * The reported costs are returned as PC_R. The difference
                             * between these and the true benchmark costs (PC_B) is used to compute
                             * the mean percent error in costs.
                             */
                            RowVector PC_R = costsys.CalcReportedCosts(ip, startingDecision);
                            RowVector PC_B = f.CalcTrueProductCosts();
                            double    MPE  = PC_B.Zip(PC_R, (pc_b, pc_r) => Math.Abs(pc_b - pc_r) / pc_b).Sum() / PC_B.Dimension;
                            Output.LogCostSysError(costsys, firmID, costSysID, startingDecision, PC_B, PC_R, MPE);

                            /* Assume the firm implements the decision startingDecision. Upon
                             * doing so, it will observe total resource consumption. It will then
                             * allocate resources to cost pools, as per the B parameter of the cost
                             * system, choose drivers as per the D parameter of the cost system,
                             * and then allocate resources to cost objects and compute reported costs.
                             * The reported costs are returned as PC_R. Upon observing the
                             * reported costs, the firm may wish to update its original decision. When
                             * it implements the updated decision, costs will change again. The outcome
                             * of this process will either be an equilibrium decision (fixed point), or
                             * a cycle of decisions.
                             */
                            (CostSystemOutcomes stopCode, RowVector endingDecision) = costsys.EquilibriumCheck(ip, startingDecision);
                            Output.LogCostSysLoop(costsys, firmID, costSysID, startingDecision, endingDecision, stopCode);
                        }
                    }
                }
            }

            #endregion

            Console.WriteLine("Writing output files...");
            Output.WriteOutput();
            Console.WriteLine("Done!");
        }
コード例 #9
0
        /// <summary>
        /// Reads the input parameters from a text file.
        /// Verifies that all input values are valid, and runs the
        /// method EnforceConstraints().
        /// </summary>
        /// <param name="inputFileName">An object that encapsulates the input file.</param>
        public InputParameters(FileInfo inputFileName)
        {
            // The data structure dictMembers keeps track of the public properties
            // and fields that have been assigned to. The constructor checks that all
            // parameters are assigned to.
            Dictionary <string, bool> dictMembers = new Dictionary <string, bool>();

            // The following code uses Reflection to obtain a list of all public
            // properties and fields, and adds their names to the dictionary.
            MemberInfo[] members = this.GetType().GetProperties();
            foreach (MemberInfo mi in members)
            {
                dictMembers.Add(mi.Name, false);
            }
            members = this.GetType().GetFields();
            foreach (MemberInfo mi in members)
            {
                dictMembers.Add(mi.Name, false);
            }

            // The remaining code in this constructor reads input file, line by line,
            // and sets the fields of this class.
            string[] mySplit;
            char[]   separator = { ',' };
            string[] fileLines = File.ReadAllLines(inputFileName.FullName);

            // Each line of the file should have the format:
            // Parameter_name,value1,value2,...
            foreach (string line in fileLines)
            {
                // Skip comment lines
                if (line.StartsWith("//"))
                {
                    continue;
                }

                mySplit = line.Trim().Split(separator);
                if (mySplit.Length < 2)
                {
                    string s =
                        String.Format(
                            "The input line:{0}{1}{0} is invalid. Enter parameter name, a comma, and then a value or comma-separated list of values",
                            Environment.NewLine, line
                            );
                    throw new InvalidDataException(s);
                }

                string paramName = mySplit[0].Trim().ToUpper();

                // Make sure only one data value was given for the parameter, unless
                // a list is allowed. At present, only ACP, PACP, and PDR accept lists.
                int numParams = mySplit.Length - 1;
                if ((paramName != "ACP") && (paramName != "PACP") && (paramName != "PDR"))
                {
                    if (numParams != 1)
                    {
                        string msg = String.Format("Looks like you entered multiple values for parameter {0}. Only 1 is allowed.", paramName);
                        throw new InvalidDataException(msg);
                    }
                }

                switch (paramName)
                {
                case "TR":
                    TR = ParseDouble(mySplit[1]);
                    dictMembers["TR"] = true;
                    break;

                case "CO":
                    CO = ParseInt(mySplit[1]);
                    dictMembers["CO"] = true;
                    break;

                case "RCP":
                    RCP = ParseInt(mySplit[1]);
                    dictMembers["RCP"] = true;
                    break;

                case "NUM_FIRMS":
                    NUM_FIRMS = ParseInt(mySplit[1]);
                    dictMembers["NUM_FIRMS"] = true;
                    break;

                case "DISP1":
                    DISP1 = ParseInt(mySplit[1]);
                    dictMembers["DISP1"] = true;
                    break;

                case "DISP2_MIN":
                    DISP2_MIN = ParseDouble(mySplit[1]);
                    dictMembers["DISP2_MIN"] = true;
                    break;

                case "DISP2_MAX":
                    DISP2_MAX = ParseDouble(mySplit[1]);
                    dictMembers["DISP2_MAX"] = true;
                    break;

                case "DNS_MIN":
                    DNS_MIN = ParseDouble(mySplit[1]);
                    dictMembers["DNS_MIN"] = true;
                    break;

                case "DNS_MAX":
                    DNS_MAX = ParseDouble(mySplit[1]);
                    dictMembers["DNS_MAX"] = true;
                    break;

                case "ACP":
                    SetACP(ParseIntList(mySplit.Skip(1)));
                    dictMembers["ACP"] = true;
                    break;

                case "PACP":
                    SetPACP(ParseIntList(mySplit.Skip(1)));
                    dictMembers["PACP"] = true;
                    break;

                case "PDR":
                    SetPDR(ParseIntList(mySplit.Skip(1)));
                    dictMembers["PDR"] = true;
                    break;

                case "NUM":
                    NUM = ParseInt(mySplit[1]);
                    dictMembers["NUM"] = true;
                    break;

                case "MISCPOOLSIZE":
                    MISCPOOLSIZE = ParseDouble(mySplit[1]);
                    dictMembers["MISCPOOLSIZE"] = true;
                    break;

                case "COR1LB":
                    COR1LB = ParseDouble(mySplit[1]);
                    dictMembers["COR1LB"] = true;
                    break;

                case "COR1UB":
                    COR1UB = ParseDouble(mySplit[1]);
                    dictMembers["COR1UB"] = true;
                    break;

                case "COR2LB":
                    COR2LB = ParseDouble(mySplit[1]);
                    dictMembers["COR2LB"] = true;
                    break;

                case "COR2UB":
                    COR2UB = ParseDouble(mySplit[1]);
                    dictMembers["COR2UB"] = true;
                    break;

                case "CC":
                    CC = ParseDouble(mySplit[1]);
                    dictMembers["CC"] = true;
                    break;

                case "MARLB":
                    MARLB = ParseDouble(mySplit[1]);
                    dictMembers["MARLB"] = true;
                    break;

                case "MARUB":
                    MARUB = ParseDouble(mySplit[1]);
                    dictMembers["MARUB"] = true;
                    break;

                case "STARTMIX":
                    STARTMIX = ParseInt(mySplit[1]);
                    dictMembers["STARTMIX"] = true;
                    break;

                case "EXCLUDE":
                    EXCLUDE = ParseDouble(mySplit[1]);
                    dictMembers["EXCLUDE"] = true;
                    break;

                case "USESEED":
                    if (mySplit[1].Equals("TRUE", StringComparison.OrdinalIgnoreCase))
                    {
                        USESEED = true;
                    }
                    else if (mySplit[1].Equals("FALSE", StringComparison.OrdinalIgnoreCase))
                    {
                        USESEED = false;
                    }
                    else
                    {
                        throw new InvalidDataException("Invalid value for USESEED in input file.");
                    }
                    dictMembers["USESEED"] = true;
                    break;

                case "SEED":
                    SEED = ParseLong(mySplit[1]);
                    dictMembers["SEED"] = true;
                    break;

                case "HYSTERESIS":
                    HYSTERESIS = ParseDouble(mySplit[1]);
                    dictMembers["HYSTERESIS"] = true;
                    break;

                default:
                    string msg = String.Format("The parameter name {0} is invalid. Aborting.", paramName);
                    throw new InvalidDataException(msg);
                }
            }

            // Make sure all parameters have been initialized (i.e. input file is complete)
            var q = dictMembers.Where(kvp => kvp.Value == false);

            if (q.Count() > 0)
            {
                Console.WriteLine("The following parameters did not appear in your input file.");
                Console.WriteLine("Please add them and run the simulation again.");
                Console.WriteLine("Aborting.");

                foreach (KeyValuePair <string, bool> kvp in q)
                {
                    Console.WriteLine(kvp.Key);
                }

                throw new MissingFieldException();
            }

            EnforceConstraints();

            if (this.USESEED)
            {
                GenRandNumbers.SetSeed(this.SEED);
            }
            else
            {
                GenRandNumbers.SetSeed(DateTime.Now.Ticks);
            }
        }