private static SetInformation[] BuildAllSets([NotNull] HeaderArrayFile arrayFile)
{
int[] sizes = arrayFile["SSZ "].As <int>().Values.ToArray();
char[] intertemporal = arrayFile["STTP"].As <char>().Values.ToArray();
string[] names = arrayFile["STNM"].As <string>().Values.ToArray();
string[] descriptions = arrayFile["STLB"].As <string>().Values.ToArray();
string[] elements = arrayFile["STEL"].As <string>().Values.ToArray();
SetInformation[] result = new SetInformation[names.Length];
int counter = 0;
for (int i = 0; i < names.Length; i++)
{
result[i] =
new SetInformation(
names[i],
descriptions[i],
intertemporal[i] == 'i',
sizes[i],
new ArraySegment <string>(elements, counter, sizes[i]));
counter += sizes[i];
}
return(result);
}
private static ParallelQuery <SolutionArray> BuildSolutionArrays([NotNull] HeaderArrayFile arrayFile)
{
int[] numberOfSets = arrayFile["VCNI"].As <int>().Values.ToArray();
string[] names = arrayFile["VCNM"].As <string>().Values.ToArray();
string[] descriptions = arrayFile["VCL0"].As <string>().Values.ToArray();
string[] unitTypes = arrayFile["VCLE"].As <string>().Values.ToArray();
char[] changeTypes = arrayFile["VCT0"].As <char>().Values.ToArray();
char[] variableTypes = arrayFile["VCS0"].As <char>().Values.ToArray();
KeyValuePair <string, IImmutableList <string> >[][] sets = VariableIndexedCollectionsOfSets(arrayFile);
return
(ParallelEnumerable.Range(0, names.Length)
.Select(
x =>
new SolutionArray(
x,
numberOfSets[x],
names[x],
descriptions[x],
unitTypes[x],
(ModelChangeType)changeTypes[x],
(ModelVariableType)variableTypes[x],
sets[x])));
}
/// <summary>
/// Executes the selected tests.
/// </summary>
/// <param name="input">
/// The input file.
/// </param>
/// <param name="binaryOutput">
/// The binary output file.
/// </param>
/// <param name="jsonOutput">
/// The json output file.
/// </param>
/// <param name="option">
/// The bit flags indicating which tests to perform.
/// </param>
private static void Test(string input, string binaryOutput, string jsonOutput, TestOptions option)
{
Console.WriteLine($"Reading {nameof(input)} with {nameof(HeaderArrayFile.Read)} at {DateTime.Now}.");
HeaderArrayFile arrays = HeaderArrayFile.Read(input);
if (option.HasFlag(TestOptions.WriteBinary))
{
Console.WriteLine($"Writing {nameof(arrays)} to {nameof(binaryOutput)} with {nameof(HeaderArrayFile.BinaryWriter)} at {DateTime.Now}.");
HeaderArrayFile.BinaryWriter.Write(binaryOutput, arrays);
}
if (option.HasFlag(TestOptions.WriteJson))
{
Console.WriteLine($"Writing {nameof(arrays)} to {nameof(jsonOutput)} with {nameof(HeaderArrayFile.JsonWriter)} at {DateTime.Now}.");
HeaderArrayFile.JsonWriter.Write(jsonOutput, arrays);
}
if (option.HasFlag(TestOptions.ReadJson))
{
Console.WriteLine($"Reading {nameof(jsonOutput)} with {nameof(HeaderArrayFile.JsonReader)} at {DateTime.Now}.");
HeaderArrayFile.JsonReader.Read(jsonOutput);
}
if (option.HasFlag(TestOptions.ValidateSets))
{
Console.WriteLine($"Running {nameof(HeaderArray.ValidateSets)} on {nameof(arrays)} at {DateTime.Now}.");
arrays.ValidateSets(Console.Out);
}
Console.WriteLine($"Completed test at {DateTime.Now}");
}
/// <summary>
/// Program entry point.
/// </summary>
public static void Main()
{
Console.WriteLine($"Reading at {DateTime.Now}.");
HeaderArrayFile arrays = HeaderArrayFile.Read($"{Directory.GetCurrentDirectory()}\\basedata.har");
Console.WriteLine($"Writing {nameof(arrays)} with {nameof(HeaderArrayFile.JsonWriter)} at {DateTime.Now}.");
HeaderArrayFile.JsonWriter.Write($"{Directory.GetCurrentDirectory()}\\basedata.harx", arrays);
// Test(Input[1], Output[0], Output[1], TestOptions.All);
//
// Console.WriteLine(HeaderArray<float>.JsonSchema);
//
// Console.ReadLine();
}
private static KeyValuePair <string, IImmutableList <string> >[][] VariableIndexedCollectionsOfSets([NotNull] HeaderArrayFile arrayFile)
{
SetInformation[] setInformation = BuildAllSets(arrayFile).ToArray();
int[] pointerIntoVcsn = arrayFile["VCSP"].As <int>().Values.ToArray();
int[] setsPerVariable = arrayFile["VCNI"].As <int>().Values.ToArray();
int[] setPositions = arrayFile["VCSN"].As <int>().Values.ToArray();
KeyValuePair <string, IImmutableList <string> >[][] arraySetInfo = new KeyValuePair <string, IImmutableList <string> > [pointerIntoVcsn.Length][];
for (int i = 0; i < pointerIntoVcsn.Length; i++)
{
arraySetInfo[i] = new KeyValuePair <string, IImmutableList <string> > [setsPerVariable[i]];
int pointer = pointerIntoVcsn[i] - 1;
for (int j = 0; j < arraySetInfo[i].Length; j++)
{
SetInformation set = setInformation[setPositions[pointer + j] - 1];
arraySetInfo[i][j] = new KeyValuePair <string, IImmutableList <string> >(set.Name, set.Elements);
}
}
return(arraySetInfo);
}
private IEnumerable <IHeaderArray> BuildHeaderArrays([NotNull] FilePath file)
{
HeaderArrayFile arrayFile = HeaderArrayFile.BinaryReader.Read(file);
// Variable information.
int[] countOfComponentsInVariable = arrayFile["VNCP"].As <int>().Values.ToArray();
// Endogenous variable components and information.
int[] pointersToCumulative = arrayFile["PCUM"].As <int>().Values.ToArray();
int[] countInCumulative = arrayFile["CMND"].As <int>().Values.ToArray();
float[] cumulativeResults = arrayFile["CUMS"].As <float>().Values.ToArray();
// Exogenous variable components and list of positions (where OREX != array.Length).
int[] countOfExogenous = arrayFile["OREX"].As <int>().Values.ToArray();
int[] positionsOfExogenous = arrayFile["OREL"].As <int>().Values.ToArray();
// Shocked variable information
int[] numberOfShockedComponents = arrayFile["SHCK"].As <int>().Values.ToArray();
int[] pointersToShockValues = arrayFile["PSHK"].As <int>().Values.ToArray();
int[] positionsOfShockValues = arrayFile["SHCL"].As <int>().Values.ToArray();
float[] shockValues = arrayFile["SHOC"].As <float>().Values.ToArray();
return
(BuildSolutionArrays(arrayFile).Where(x => x.IsBacksolvedOrCondensed)
.OrderBy(x => x.VariableIndex)
.Select(BuildNextArray));
// Local method here to limit passing arrays as parameters.
IHeaderArray BuildNextArray(SolutionArray array, int index)
{
float[] values = new float[array.Count];
// When the array is condensed/backsolved and the pointer is empty, its exogenous.
int pointer = pointersToCumulative[index] - 1;
if (pointer != -1)
{
Array.Copy(cumulativeResults, pointer, values, 0, countInCumulative[index]);
}
ShiftExogenous(values);
Shocks(values);
return
(HeaderArray <float> .Create(
array.Name,
array.Name,
array.Description,
HeaderArrayType.RE,
array.Sets.Select(x => x.Value.Count).Concat(Enumerable.Repeat(1, 7)).Take(7),
values,
array.Sets));
// Shifts existing entries to their appropriate positions to create gaps for exogenous values.
void ShiftExogenous(float[] inputArray)
{
if (array.Count == countOfExogenous[index])
{
Array.Clear(inputArray, 0, inputArray.Length);
return;
}
float[] withGaps = inputArray;
int nextValidPosition = 0;
for (int i = 0; i < index; i++)
{
if (countOfExogenous[i] != countOfComponentsInVariable[i])
{
nextValidPosition += countOfExogenous[i];
}
}
for (int i = 0; i < countOfExogenous[index]; i++)
{
int position = positionsOfExogenous[nextValidPosition + i] - 1;
Array.Copy(withGaps, position, withGaps, position + 1, withGaps.Length - position - 1);
withGaps[position] = default(float);
}
}
// Adds shocks to open positions to a copy of the input array.
void Shocks(float[] inputArray)
{
float[] withShocks = inputArray;
int shockedCount = numberOfShockedComponents[index];
if (shockedCount == 0)
{
return;
}
int shockPointer = pointersToShockValues[index] - 1;
int nextValidPosition = 0;
for (int i = 0; i < index - 1; i++)
{
if (numberOfShockedComponents[i] != countOfComponentsInVariable[i])
{
nextValidPosition += numberOfShockedComponents[i];
}
}
for (int i = 0; i < shockedCount; i++)
{
int position = array.Count == shockedCount ? i : positionsOfShockValues[nextValidPosition + i] - 1;
float value = shockValues[shockPointer + i];
withShocks[position] = value;
}
}
}
}
