public void SendText(string text)
{
if (OutputConsole.InvokeRequired)
{
ANN.UI.StringArgReturningVoidDelegate d = new ANN.UI.StringArgReturningVoidDelegate(SendText);
this.Invoke(d, new object[] { text });
}
else
{
OutputConsole.AppendText(text);
}
}
public void WriteConsole(object text)
{
OutputConsole.AppendText(text.ToString() + "\n");
}
public ProgramGenerationsGUI()
{
InitializeComponent();
// Number of Generations
// Generation 0 always have only 1 patient
// Generations 1 and forward have the number of patients defined in the PATIENTS variable
int Generations = 2;
// this array is called inside the RunPatients function
// it is an array because if there is increment from the infection cycle from one patient to another,
// different values for infection cycle have to be stored
int[] InfectionCycle = new int[] { 2, 4 };
// Number of Patients in Generation 1
int Gen1Patients;
// Number of Cycles
int Cycles = 10;
// Number of Classes
int Classes = 11;
// The "InitialParticles" is the initial amount of viral particles, that is: the initial virus population of a infection.
int InitialParticles = 5;
int InfectionParticles = 20;
int MaxParticles = 1000000; // Limite máximo de partículas que quero impor para cada ciclo (linha)
double[] DeleteriousProbability = new double[Cycles];
double[] BeneficialProbability = new double[Cycles];
bool BeneficialIncrement = false; // if true, beneficial probability will increase by INCREMENT each cycle
// if false, it will change from a fixed value to another fixed value, at the chosen cycle
bool DeleteriousIncrement = false; // if true, deleterious probability will increase by INCREMENT each cycle
// if false, it will change from a fixed value to another fixed value, at the chosen cycle
// Lists to keep the number of particles that go up or down the classes, during mutations
int[][,] ClassUpParticles = new int[Generations][, ];
int[][,] ClassDownParticles = new int[Generations][, ];
MainFunction();
void MainFunction()
{
Random rnd = new Random();
// number of patients at 1st generation is defined by the number of cycles that
// occur infection
Gen1Patients = InfectionCycle.GetLength(0);
// create and start the Stopwatch Class. From: https://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
//Thread.Sleep(10000);
// Declaring the three-dimensional Matrix: it has p Patient, x lines of Cycles and y columns of Classes, defined by the variables above.
int[][,,] Matrix = new int[Generations][, , ];
for (int g = 0; g < Generations; g++)
{
Matrix[g] = new int[(int)Math.Pow(Gen1Patients, g), Cycles, Classes];
//InfectionCycle[g] = new int[(int)Math.Pow(Gen1Patients, g)];
ClassUpParticles[g] = new int[(int)Math.Pow(Gen1Patients, g), Cycles];
ClassDownParticles[g] = new int[(int)Math.Pow(Gen1Patients, g), Cycles];
}
//FillInfectionCycleArray(6, 0); // FIRST PARAMETER: initial cycle, SECOND PARAMENTER: increment
if (DeleteriousIncrement)
{
FillDeleteriousArrayWithIncrement(0.3, 0.1); // FIRST PARAMETER: initial probability, SECOND PARAMENTER: increment
}
else
{
FillDeleteriousArray(0.8, 0.9, 5); // FIRST PARAMETER: first probability, SECOND PARAMENTER: second probability
// THIRD PARAMETER: cycle to change from first probability to second probability
}
if (BeneficialIncrement)
{
FillBeneficialArrayWithIncrement(0.0003, 0.0001); // FIRST PARAMETER: initial probability, SECOND PARAMENTER: increment
}
else
{
FillBeneficialArray(0.0003, 0.0008, 5); // FIRST PARAMETER: first probability, SECOND PARAMENTER: second probability
// THIRD PARAMETER: cycle to change from first probability to second probability
}
// The Matrix starts on the Patient 0, 10th position (column) on the line zero.
// The "InitialParticles" is the amount of viral particles that exists in the class 10 on the cycle zero.
// That is: these 5 particles have the potential to create 10 particles each.
Matrix[0][0, 0, 10] = InitialParticles;
RunPatients(Matrix, rnd);
stopWatch.Stop();
// Get the elapsed time as a TimeSpan value.
TimeSpan ts = stopWatch.Elapsed;
PrintOutput(Matrix);
// Format and display the TimeSpan value.
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
OutputConsole.AppendText(Environment.NewLine);
OutputConsole.AppendText("Total Run Time: " + elapsedTime);
}
void FillDeleteriousArray(double FirstProbability, double SecondProbability, int ChangeCycle)
{
for (int i = 0; i < DeleteriousProbability.GetLength(0); i++)
{
if (i <= ChangeCycle)
{
DeleteriousProbability[i] = FirstProbability;
}
else
{
DeleteriousProbability[i] = SecondProbability;
}
}
}
void FillDeleteriousArrayWithIncrement(double InitialProbability, double Increment)
{
for (int i = 0; i < DeleteriousProbability.GetLength(0); i++)
{
if (i == 0)
{
DeleteriousProbability[i] = InitialProbability;
}
else
{
if (DeleteriousProbability[i - 1] + Increment <= (1 - BeneficialProbability.GetLength(0)))
{
DeleteriousProbability[i] = DeleteriousProbability[i - 1] + Increment;
}
else
{
DeleteriousProbability[i] = DeleteriousProbability[i - 1];
}
}
}
}
void FillBeneficialArray(double FirstProbability, double SecondProbability, int ChangeCycle)
{
for (int i = 0; i < BeneficialProbability.GetLength(0); i++)
{
if (i <= ChangeCycle)
{
BeneficialProbability[i] = FirstProbability;
}
else
{
BeneficialProbability[i] = SecondProbability;
}
}
}
void FillBeneficialArrayWithIncrement(double InitialProbability, double Increment)
{
for (int i = 0; i < BeneficialProbability.GetLength(0); i++)
{
if (i == 0)
{
BeneficialProbability[i] = InitialProbability;
}
else
{
if (BeneficialProbability[i - 1] + Increment <= (1 - DeleteriousProbability.GetLength(0)))
{
BeneficialProbability[i] = BeneficialProbability[i - 1] + Increment;
}
else
{
BeneficialProbability[i] = BeneficialProbability[i - 1];
}
}
}
}
void RunPatients(int[][,,] Matrix, Random rndx)
{
// Main Loop to create more particles on the next Cycles from the Cycle Zero (lines values).
// Each matrix position will bring a value. This value will be mutiplied by its own class number (column value).
for (int g = 0; g < Generations; g++)
{
for (int p = 0; p < Matrix[g].GetLength(0); p++)
{
Console.WriteLine("Patient started: GEN {0} - P {1}", g, p);
for (int i = 0; i < Cycles; i++)
{
for (int j = 0; j < Classes; j++)
{
if (i > 0)
{
// Multiplies the number os particles from de previous Cycle by the Class number which belongs.
// This is the progeny composition.
//Matrix[p, i, j] = Matrix[p, (i - 1), j] * j;
Matrix[g][p, i, j] = Matrix[g][p, (i - 1), j] * j;
}
}
CutOffMaxParticlesPerCycle(Matrix, g, p, i, rndx);
ApplyMutationsProbabilities(Matrix, g, p, i);
// if the INFECTIONCYLE array contains the cycle "i"
// and it is not the last generation, make infection
if (InfectionCycle.Contains(i) && (g < Generations - 1))
{
PickRandomParticlesForInfection(Matrix, g, p, i, rndx);
//Console.WriteLine("*** INFECTION CYCLE *** {0}", i);
}
// print which Cycle was finished just to give user feedback, because it may take too long to run.
//Console.WriteLine("Cycles processed: {0}", i);
}
//Console.WriteLine("Patients processed: GEN {0} - P {1}", g, p);
}
}
}
void ApplyMutationsProbabilities(int[][,,] Matrix, int g, int p, int i)
{
// This function will apply three probabilities: Deleterious, Beneficial or Neutral.
// Their roles is to simulate real mutations of virus genome.
// So here, there are mutational probabilities, which will bring an stochastic scenario sorting the progenies by the classes.
int UpParticles = 0;
int DownParticles = 0;
// Here a random number greater than zero and less than one is selected.
Random rnd = new Random();
double RandomNumber;
// array to store the number of particles of each class, in the current cycle
int[] ThisCycle = new int[Classes];
for (int j = 0; j < Classes; j++)
{
// storing the number of particles of each class (j)
ThisCycle[j] = Matrix[g][p, i, j];
}
for (int j = 0; j < Classes; j++)
{
if (ThisCycle[j] > 0 && i > 0)
{
for (int particles = ThisCycle[j]; particles > 0; particles--)
{
// In this loop, for each particle removed from the Matrix [i,j], a random number is selected.
RandomNumber = rnd.NextDouble();
// If the random number is less than the DeleteriousProbability defined, one particle of the previous Cycle will
// decrease one Class number. Remember this function is inside a loop for each i and each j values.
// So this loop will run through the whole Matrix, particle by particle on its own positions.
if (RandomNumber < DeleteriousProbability[i])
// Deleterious Mutation = 90,0% probability (0.9)
{
Matrix[g][p, i, (j - 1)] = Matrix[g][p, i, (j - 1)] + 1;
Matrix[g][p, i, j] = Matrix[g][p, i, j] - 1;
DownParticles++;
}
else if (RandomNumber < (DeleteriousProbability[i] + BeneficialProbability[i]))
// Beneficial Mutation = 0,5% probability (0.005)
{
if (j < (Classes - 1))
{
Matrix[g][p, i, (j + 1)] = Matrix[g][p, i, (j + 1)] + 1;
Matrix[g][p, i, j] = Matrix[g][p, i, j] - 1;
}
if (j == Classes)
{
Matrix[g][p, i, j] = Matrix[g][p, i, j] + 1;
}
UpParticles++;
}
}
}
}
ClassUpParticles[g][p, i] = UpParticles;
ClassDownParticles[g][p, i] = DownParticles;
}
int ParticlesInCycle(int[][,,] Matrix, int g, int p, int i)
{
// This funtion brings the sum value of particles by Cycle.
int Particles = 0;
for (int j = 0; j < Classes; j++)
{
Particles = Particles + Matrix[g][p, i, j];
}
return(Particles);
}
void CutOffMaxParticlesPerCycle(int[][,,] Matrix, int g, int p, int i, Random rndx)
{
int ParticlesInThisCycle = ParticlesInCycle(Matrix, g, p, i); // Quantidade de partículas somadas por ciclo (linha)
int[] StatusR = new int[Classes]; // Declarando o array que é a lista abaixo
// Se, x = ParticlesInCycle, for maior do que o núm MaxParticles definido, então...
if (ParticlesInThisCycle > MaxParticles)
{
// Para cada valor de x iniciando no valor de soma das partículas por ciclo;
// sendo x, ou seja, esta soma, maior do que o limite MaxParticles definido;
// então, diminua em uma unidade a soma das partículas por ciclo até que atinja o limite MaxParticles definido.
for (int Particles = ParticlesInCycle(Matrix, g, p, i); Particles > MaxParticles; Particles--)
// PARTICLES is equal to PARTICLESINTHISCYCLE, but we don't want to modifify PARTICLESINTHISCYCLE while the for loop is running
// also, PARTICLESINTHISCYCLE was created outside the for loop, for other purpose
{
StatusR[0] = Matrix[g][p, i, 0];
StatusR[1] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1];
StatusR[2] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2];
StatusR[3] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3];
StatusR[4] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4];
StatusR[5] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5];
StatusR[6] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6];
StatusR[7] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7];
StatusR[8] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7] + Matrix[g][p, i, 8];
StatusR[9] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7] + Matrix[g][p, i, 8] + Matrix[g][p, i, 9];
StatusR[10] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7] + Matrix[g][p, i, 8] + Matrix[g][p, i, 9] + Matrix[g][p, i, 10];
// Gero um número aleatório de 0 ao limite do valor de soma de partículas por ciclo (linha) = ParticlesInCycle
// int RandomMaxParticles;
int rndParticle = rndx.Next(1, ParticlesInCycle(Matrix, g, p, i));
// Aqui gero as condições para saber de qual classe serão retiradas as partículas para que
// ParticlesInCycle atinja o limite estipulado por MaxParticles
if (rndParticle > 0 && rndParticle <= StatusR[0])
{
Matrix[g][p, i, 0] = Matrix[g][p, i, 0] - 1;
}
if (rndParticle > StatusR[0] && rndParticle <= StatusR[1])
{
Matrix[g][p, i, 1] = Matrix[g][p, i, 1] - 1;
}
if (rndParticle > StatusR[1] && rndParticle <= StatusR[2])
{
Matrix[g][p, i, 2] = Matrix[g][p, i, 2] - 1;
}
if (rndParticle > StatusR[2] && rndParticle <= StatusR[3])
{
Matrix[g][p, i, 3] = Matrix[g][p, i, 3] - 1;
}
if (rndParticle > StatusR[3] && rndParticle <= StatusR[4])
{
Matrix[g][p, i, 4] = Matrix[g][p, i, 4] - 1;
}
if (rndParticle > StatusR[4] && rndParticle <= StatusR[5])
{
Matrix[g][p, i, 5] = Matrix[g][p, i, 5] - 1;
}
if (rndParticle > StatusR[5] && rndParticle <= StatusR[6])
{
Matrix[g][p, i, 6] = Matrix[g][p, i, 6] - 1;
}
if (rndParticle > StatusR[6] && rndParticle <= StatusR[7])
{
Matrix[g][p, i, 7] = Matrix[g][p, i, 7] - 1;
}
if (rndParticle > StatusR[7] && rndParticle <= StatusR[8])
{
Matrix[g][p, i, 8] = Matrix[g][p, i, 8] - 1;
}
if (rndParticle > StatusR[8] && rndParticle <= StatusR[9])
{
Matrix[g][p, i, 9] = Matrix[g][p, i, 9] - 1;
}
if (rndParticle > StatusR[9] && rndParticle <= StatusR[10])
{
Matrix[g][p, i, 10] = Matrix[g][p, i, 10] - 1;
}
}
}
}
void PickRandomParticlesForInfection(int[][,,] Matrix, int g, int p, int i, Random rndx)
{
bool NoParticlesForInfection = false;
// array to store the particles that will infect patients of the next generation
// it is just a 1D array (a list) where each index is a class
int[] InfectedParticles = new int[Classes];
int ParticlesInThisCycle = ParticlesInCycle(Matrix, g, p, i); // Quantidade de partículas somadas por ciclo (linha)
int[] StatusR = new int[Classes]; // TODO melhorar o nome deste array
for (int ParticlesSelected = 0; ParticlesSelected < InfectionParticles; ParticlesSelected++)
{
StatusR[0] = Matrix[g][p, i, 0];
StatusR[1] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1];
StatusR[2] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2];
StatusR[3] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3];
StatusR[4] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4];
StatusR[5] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5];
StatusR[6] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6];
StatusR[7] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7];
StatusR[8] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7] + Matrix[g][p, i, 8];
StatusR[9] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7] + Matrix[g][p, i, 8] + Matrix[g][p, i, 9];
StatusR[10] = Matrix[g][p, i, 0] + Matrix[g][p, i, 1] + Matrix[g][p, i, 2] + Matrix[g][p, i, 3] + Matrix[g][p, i, 4] + Matrix[g][p, i, 5] + Matrix[g][p, i, 6] + Matrix[g][p, i, 7] + Matrix[g][p, i, 8] + Matrix[g][p, i, 9] + Matrix[g][p, i, 10];
// Gero um número aleatório de 0 ao limite do valor de soma de partículas por ciclo (linha) = ParticlesInCycle
// int RandomMaxParticles;
if (ParticlesInThisCycle > 0)
{
int rndParticle = rndx.Next(1, ParticlesInThisCycle);
// Aqui gero as condições para saber de qual classe serão retiradas as partículas para que
// ParticlesSelected atinja o limite estipulado por InfectioParticles
if (rndParticle > 0 && rndParticle <= StatusR[0])
{
InfectedParticles[0] += 1;
Matrix[g][p, i, 0] -= 1;
}
if (rndParticle > StatusR[0] && rndParticle <= StatusR[1])
{
InfectedParticles[1] += 1;
Matrix[g][p, i, 1] -= 1;
}
if (rndParticle > StatusR[1] && rndParticle <= StatusR[2])
{
InfectedParticles[2] += 1;
Matrix[g][p, i, 2] -= 1;
}
if (rndParticle > StatusR[2] && rndParticle <= StatusR[3])
{
InfectedParticles[3] += 1;
Matrix[g][p, i, 3] -= 1;
}
if (rndParticle > StatusR[3] && rndParticle <= StatusR[4])
{
InfectedParticles[4] += 1;
Matrix[g][p, i, 4] -= 1;
}
if (rndParticle > StatusR[4] && rndParticle <= StatusR[5])
{
InfectedParticles[5] += 1;
Matrix[g][p, i, 5] -= 1;
}
if (rndParticle > StatusR[5] && rndParticle <= StatusR[6])
{
InfectedParticles[6] += 1;
Matrix[g][p, i, 6] -= 1;
}
if (rndParticle > StatusR[6] && rndParticle <= StatusR[7])
{
InfectedParticles[7] += 1;
Matrix[g][p, i, 7] -= 1;
}
if (rndParticle > StatusR[7] && rndParticle <= StatusR[8])
{
InfectedParticles[8] += 1;
Matrix[g][p, i, 8] -= 1;
}
if (rndParticle > StatusR[8] && rndParticle <= StatusR[9])
{
InfectedParticles[9] += 1;
Matrix[g][p, i, 9] -= 1;
}
if (rndParticle > StatusR[9] && rndParticle <= StatusR[10])
{
InfectedParticles[10] += 1;
Matrix[g][p, i, 10] -= 1;
}
}
else
{
NoParticlesForInfection = true;
}
}
// if there are no particles for infection, there is no infection
if (NoParticlesForInfection)
{
Console.WriteLine("Patient {0} Cycle {1} has no particles.\t\t", p, i);
}
else
{
InfectPatients(Matrix, InfectedParticles, g, p, i, rndx);
}
}
void InfectPatients(int[][,,] Matrix, int[] InfectedParticles, int g, int p, int i, Random rndx)
{
int AmountOfParticlesAvailable = InfectedParticles[0] + InfectedParticles[1] + InfectedParticles[2] + InfectedParticles[3] +
InfectedParticles[4] + InfectedParticles[5] + InfectedParticles[6] + InfectedParticles[7] +
InfectedParticles[8] + InfectedParticles[9] + InfectedParticles[10];
//Console.WriteLine(AmountOfParticlesAvailable);
int[] PatientsToInfect = new int[Gen1Patients];
// each patient will infect a group of patients of size Gen1Patients
int LastPatient = ((p + 1) * Gen1Patients) - 1; // the last patient of this group
int FirstPatient = LastPatient - (Gen1Patients - 1); // the first patient of this group
for (int x = 0; x < Gen1Patients; x++)
{
PatientsToInfect[x] = FirstPatient + x;
//Console.WriteLine(PatientsToInfect[x]);
}
//Console.WriteLine(FirstPatient);
//Console.WriteLine(LastPatient);
int patient = PatientsToInfect[Array.IndexOf(InfectionCycle, i)];
while (AmountOfParticlesAvailable > 0)
{
int rndClass = rndx.Next(0, Classes);
if (InfectedParticles[rndClass] > 0) // there is at least one particle in the class selected
{
Matrix[g + 1][patient, 0, rndClass] += 1;
//ParticlesReceived[patient] += 1;
InfectedParticles[rndClass] -= 1;
AmountOfParticlesAvailable--;
}
}
Console.WriteLine("G {0} P {1} infected G {2} P {3}", g, p, g + 1, patient);
}
void PrintOutput(int[][,,] Matrix)
{
double PercentageOfParticlesUp = 0.0;
double PercentageOfParticlesDown = 0.0;
//StreamWriter writer = new StreamWriter("numbers.txt");
// The writer will bring the output file (txt in this case)
// Ensure the writer will be closed when no longer used
//using (writer)
{
// Formatting Output for the Console screen.
OutputConsole.AppendText("\t\tR0\tR1\tR2\tR3\tR4\tR5\tR6\tR7\tR8\tR9\tR10");
OutputConsole.AppendText(Environment.NewLine);
OutputConsole.AppendText(Environment.NewLine);
//writer.Write("\t\tSoma\tR0\tR1\tR2\tR3\tR4\tR5\tR6\tR7\tR8\t\tR9\t\tR10\n\n");
//writer.WriteLine("\n");
for (int g = 0; g < Generations; g++)
{
for (int p = 0; p < Matrix[g].GetLength(0); p++)
{
for (int i = 0; i < Cycles; i++)
{
OutputConsole.AppendText("G " + g + " P " + p + " Cycle " + i + "\t");
//writer.Write("G {0} P {1} Cic.{2} {3}\t\t", g, p, i, ParticlesInCycle(Matrix, g, p, i));
for (int j = 0; j < Classes; j++)
{
OutputConsole.AppendText(Matrix[g][p, i, j].ToString() + "\t");
//writer.Write("{0}\t", Matrix[g][p, i, j]);
}
PercentageOfParticlesUp = (Convert.ToDouble(ClassUpParticles[g][p, i]) / Convert.ToDouble(ParticlesInCycle(Matrix, g, p, i))) * 100;
PercentageOfParticlesDown = (Convert.ToDouble(ClassDownParticles[g][p, i]) / Convert.ToDouble(ParticlesInCycle(Matrix, g, p, i))) * 100;
Console.WriteLine("\nSoma do ciclo {0}: {1}", i, ParticlesInCycle(Matrix, g, p, i));
Console.WriteLine("Particles Up: {0}, {1} %", ClassUpParticles[g][p, i], PercentageOfParticlesUp);
Console.WriteLine("Particles Down: {0}, {1} %", ClassDownParticles[g][p, i], PercentageOfParticlesDown);
Console.Write("\n");
OutputConsole.AppendText(Environment.NewLine);
OutputConsole.AppendText(Environment.NewLine);
//writer.WriteLine("\n");
}
OutputConsole.AppendText("******************************************************" +
"*************************************************************************************************");
OutputConsole.AppendText(Environment.NewLine);
}
}
}
}
}
