/// <summary>
/// Computes the profit-maximizing decision (DECT0), given true costs and selling prices.
/// </summary>
/// <returns>A [1 x ip.CO] vector of 1's and 0's. 1.0 (0.0) indicates
/// that the product is (not)included in the profit-maximizing product mix.</returns>
public RowVector CalcOptimalDecision()
{
RowVector pc_b = CalcTrueProductCosts();
RowVector productProfits = this.sp - pc_b;
// Replace each negative (nonnegative) element of productProfits with a 0.0 (1.0)
var dect0 = productProfits.Map(x => ((x < 0.0) ? 0.0 : 1.0));
return(new RowVector(dect0));
}
/// <summary>
/// Assuming the firm implements decision DECF0, this method computes
/// reported costs for this cost system, which are used to compute the firm's updated decision.
/// It iterates using the updated decision as the new starting decision until a terminal outcome
/// (e.g. equilibrium, cycle) is reached.
/// </summary>
/// <param name="ip">The current InputParameters object</param>
/// <param name="DECF0">The starting decision.</param>
/// <returns>Returns the outcome of iterations and the final decision.</returns>
public (CostSystemOutcomes stopCode, RowVector DECF1) EquilibriumCheck(InputParameters ip, RowVector DECF0)
{
#region Make local copies of firm-level variables
ColumnVector MXQ = this.firm.MXQ;
RowVector SP = this.firm.SP;
#endregion
// The initial vector of production quantities, given
// starting decision DECF0
ColumnVector q0 = MXQ.ewMultiply(DECF0);
// A list of past decisions made during the iteration process.
// If a decision appears twice on this list, then a cycle exists.
List <RowVector> pastDecisions = new List <RowVector> {
DECF0
};
// The "next" decision that the firm would make. Assume the firm
// starts with DECF0, computes resulting resource consumption,
// and reported costs (through the cost system). Given reported
// costs, it updates its decision to DECF1.
RowVector DECF1;
bool foundThisDecisionBefore;
double MAR_DROP = 1.0 - ip.HYSTERESIS;
double MAR_MAKE = 1.0 + ip.HYSTERESIS;
CostSystemOutcomes stopCode = CostSystemOutcomes.Unassigned;
bool done;
do
{
RowVector PC_R = CalcReportedCosts(ip, DECF0);
if (PC_R.Contains(double.NaN))
{
DECF1 = PC_R.Map(x => double.NaN);
}
else
{
double[] MAR = PC_R.Zip(SP, (pc_r, sp) => sp / pc_r).ToArray();
var decf1 = MAR.Zip(q0, (mar, q) =>
(q > 0.0) ? ((mar <= MAR_DROP) ? 0.0 : 1.0) : ((mar > MAR_MAKE) ? 1.0 : 0.0));
DECF1 = new RowVector(decf1.ToList());
}
ColumnVector q1 = MXQ.ewMultiply(DECF1);
if (!(foundThisDecisionBefore = pastDecisions.Contains(DECF1)))
{
pastDecisions.Add(DECF1);
}
//double ExpectedCosts = PC_R * q1;
//double TCF0 = this.firm.CalcTotCosts(q1);
done = true;
//if (q1 == q0) {
if (DECF1 == DECF0)
{
stopCode = CostSystemOutcomes.Equilibrium;
}
else if (q1.TrueForAll(qty => qty == 0.0))
{
stopCode = CostSystemOutcomes.ZeroMix;
}
else if (foundThisDecisionBefore)
{
stopCode = CostSystemOutcomes.Cycle;
}
else if (DECF1.Contains(double.NaN))
{
stopCode = CostSystemOutcomes.NaN;
}
else
{
done = false;
}
if (!done)
{
DECF0 = DECF1;
q0 = q1;
}
} while (!done);
return(stopCode, DECF1);
}
/// <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);
}
/// <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);
}
