public bool Calculate()
{
int DividendQua = 0;
int DivisorQua = 0;
if (!Serviсe.CheckNumber(Dividend, Divisor))
{
return(false);
}
return(false);
}
public bool Calculate()
{
Stage Stage1;
bool MinuendNegative = false; bool SuBtractionNegative = false; bool NegativeTemp;
int MinuendQua = 0; int MinuendQuaBefComma = 0; int MinuendQuaAftComma = 0;
int SuBtractionQua = 0; int SuBtractionQuaBefComma = 0; int SuBtractionQuaAftComma = 0;
int MaxBefComma = 0; int MaxAftComma = 0;
int index = 0;
if (!Logic)
{
if (!Serviсe.CheckNumber(Minuend, SuBtraction))
{
return(false);
}
MinuendQua = Serviсe.StringNumberQua(Minuend);
SuBtractionQua = Serviсe.StringNumberQua(SuBtraction);
if (MinuendQua > SuBtractionQua)
{
MinuendM = new double[MinuendQua];
SuBtractionM = new double[MinuendQua];
}
else
{
MinuendM = new double[SuBtractionQua];
SuBtractionM = new double[SuBtractionQua];
}
Serviсe.StringToMass(Minuend, MinuendM, MinuendQua, MinuendNegative);
Serviсe.StringToMass(SuBtraction, SuBtractionM, SuBtractionQua, SuBtractionNegative);
}
MinuendQuaBefComma = Serviсe.NumberQuaBeforeComma(MinuendM); MinuendQuaAftComma = Serviсe.NumberQuaAfterComma(MinuendM);
SuBtractionQuaBefComma = Serviсe.NumberQuaBeforeComma(SuBtractionM); SuBtractionQuaAftComma = Serviсe.NumberQuaAfterComma(SuBtractionM);
if (Logic)
{
MinuendQua = MinuendQuaBefComma + MinuendQuaAftComma;
if (MinuendQuaAftComma > 0)
{
MinuendQua++;
}
SuBtractionQua = SuBtractionQuaBefComma + SuBtractionQuaAftComma;
if (SuBtractionQuaAftComma > 0)
{
SuBtractionQua++;
}
}
MaxBefComma = Serviсe.MaxNumber(MinuendQuaBefComma, SuBtractionQuaBefComma);
MaxAftComma = Serviсe.MaxNumber(MinuendQuaAftComma, SuBtractionQuaAftComma);
index = MaxAftComma + MaxBefComma;
if (MaxAftComma > 0)
{
index++;
}
if (index > MinuendM.Length)
{
MinuendMtemp = new double[index];
SuBtractionMtemp = new double[index];
if (MaxAftComma > MinuendQuaAftComma)
{
MinuendM.CopyTo(MinuendMtemp, 0);
SuBtractionM.CopyTo(SuBtractionMtemp, index - SuBtractionM.Length);
}
else
{
SuBtractionM.CopyTo(SuBtractionMtemp, 0);
MinuendM.CopyTo(MinuendMtemp, index - MinuendM.Length);
}
MinuendM = new double[index];
SuBtractionM = new double[index];
MinuendMtemp.CopyTo(MinuendM, 0);
SuBtractionMtemp.CopyTo(SuBtractionM, 0);
}
MinuendMtemp = new double[index];
SuBtractionMtemp = new double[index];
if (Serviсe.NumberCorrect(MinuendM, SuBtractionM, MinuendMtemp, SuBtractionMtemp, MinuendQua, SuBtractionQua))
{
MinuendM = MinuendMtemp;
SuBtractionM = SuBtractionMtemp;
}
Stage1 = new Stage(index);
if (Serviсe.NumberCompare(MinuendM, SuBtractionM, MinuendNegative, SuBtractionNegative) == 2)
{
SuBtractionMtemp = new double[index];
MinuendMtemp = new double[index];
MinuendM.CopyTo(SuBtractionMtemp, 0);
SuBtractionM.CopyTo(MinuendMtemp, 0);
MinuendM = MinuendMtemp;
SuBtractionM = SuBtractionMtemp;
NegativeTemp = MinuendNegative;
MinuendNegative = SuBtractionNegative;
SuBtractionNegative = NegativeTemp;
Stage1.AnswerNegative = true;
}
MinuendM.CopyTo(Stage1.NumberOne, 0);
SuBtractionM.CopyTo(Stage1.NumberTwo, 0);
Stage1.NumberOneNegative = MinuendNegative;
Stage1.NumberTwoNegative = SuBtractionNegative;
for (int i = index - 1; i >= 0; i--)
{
if (MinuendM[i] == 0.5 || SuBtractionM[i] == 0.5)
{
Stage1.Answer[i] = 0.5;
continue;
}
if (MinuendM[i] - SuBtractionM[i] < 0)
{
Stage1.Answer[i] = 10 + MinuendM[i] - SuBtractionM[i];
if (MinuendM[i - 1] != 0.5 && SuBtractionM[i - 1] != 0.5)
{
MinuendM[i - 1]--;
}
else
{
MinuendM[i - 2]--;
}
continue;
}
Stage1.Answer[i] = MinuendM[i] - SuBtractionM[i];
}
StageSubtraction.Add(Stage1);
return(true);
}
public bool Calculate()
{
Stage Stage1;
bool AddendOneNegative = false; bool AddendTwoNegative = false;
int AddendOneQua = 0; int AddendOneQuaBefComma = 0; int AddendOneQuaAftComma = 0;
int AddendTwoQua = 0; int AddendTwoQuaBefComma = 0; int AddendTwoQuaAftComma = 0;
int MaxBefComma = 0; int MaxAftComma = 0;
int index = 0;
if (!Logic)
{
if (!Serviсe.CheckNumber(AddendOne, AddendTwo))
{
return(false);
}
AddendOneQua = Serviсe.StringNumberQua(AddendOne);
AddendTwoQua = Serviсe.StringNumberQua(AddendTwo);
if (AddendOneQua > AddendTwoQua)
{
AddendOneM = new double[AddendOneQua];
AddendTwoM = new double[AddendOneQua];
}
else
{
AddendOneM = new double[AddendTwoQua];
AddendTwoM = new double[AddendTwoQua];
}
Serviсe.StringToMass(AddendOne, AddendOneM, AddendOneQua, AddendOneNegative);
Serviсe.StringToMass(AddendTwo, AddendTwoM, AddendTwoQua, AddendTwoNegative);
}
AddendOneQuaBefComma = Serviсe.NumberQuaBeforeComma(AddendOneM); AddendOneQuaAftComma = Serviсe.NumberQuaAfterComma(AddendOneM);
AddendTwoQuaBefComma = Serviсe.NumberQuaBeforeComma(AddendTwoM); AddendTwoQuaAftComma = Serviсe.NumberQuaAfterComma(AddendTwoM);
if (Logic)
{
AddendOneQua = AddendOneQuaBefComma + AddendOneQuaAftComma;
if (AddendOneQuaAftComma > 0)
{
AddendOneQua++;
}
AddendTwoQua = AddendTwoQuaBefComma + AddendTwoQuaAftComma;
if (AddendTwoQuaAftComma > 0)
{
AddendTwoQua++;
}
}
MaxBefComma = Serviсe.MaxNumber(AddendOneQuaBefComma, AddendTwoQuaBefComma);
MaxAftComma = Serviсe.MaxNumber(AddendOneQuaAftComma, AddendTwoQuaAftComma);
index = MaxAftComma + MaxBefComma;
if (MaxAftComma > 0)
{
index++;
}
if (index > AddendOneM.Length)
{
AddendOneMtemp = new double[index];
AddendTwoMtemp = new double[index];
if (MaxAftComma > AddendOneQuaAftComma)
{
AddendOneM.CopyTo(AddendOneMtemp, 0);
AddendTwoM.CopyTo(AddendTwoMtemp, index - AddendTwoM.Length);
}
else
{
AddendTwoM.CopyTo(AddendTwoMtemp, 0);
AddendOneM.CopyTo(AddendOneMtemp, index - AddendOneM.Length);
}
AddendOneM = new double[index];
AddendTwoM = new double[index];
AddendOneMtemp.CopyTo(AddendOneM, 0);
AddendTwoMtemp.CopyTo(AddendTwoM, 0);
}
AddendOneMtemp = new double[index];
AddendTwoMtemp = new double[index];
if (Serviсe.NumberCorrect(AddendOneM, AddendTwoM, AddendOneMtemp, AddendTwoMtemp, AddendOneQua, AddendTwoQua))
{
AddendOneM = AddendOneMtemp;
AddendTwoM = AddendTwoMtemp;
}
if (index < AddendOneM.Length)
{
index = AddendOneM.Length;
}
Stage1 = new Stage(index);
AddendOneM.CopyTo(Stage1.NumberOne, 0);
AddendTwoM.CopyTo(Stage1.NumberTwo, 0);
for (int i = index - 1; i >= 0; i--)
{
if (AddendOneM[i] == 0.5 || AddendTwoM[i] == 0.5)
{
Stage1.Answer[i] = 0.5;
continue;
}
if (AddendTwoM[i] + AddendOneM[i] > 9)
{
Stage1.Answer[i] = 0;
if (i == 0)
{
AddendOneM = new double[index + 1];
Stage1.Answer.CopyTo(AddendOneM, 1);
AddendOneM[0] = 1;
Stage1.Answer = AddendOneM;
break;
}
if (AddendOneM[i - 1] != 0.5 && AddendTwoM[i - 1] != 0.5)
{
AddendOneM[i - 1]++;
}
else
{
AddendOneM[i - 2]++;
}
continue;
}
Stage1.Answer[i] = AddendTwoM[i] + AddendOneM[i];
}
StageAdd.Add(Stage1);
return(true);
}
public bool Calculate()
{
Stage Stage1;
bool MultiplierOneNegative = false; bool MultiplierTwoNegative = false;
int MultiplierOneQua = 0; int MultiplierOneQuaBefComma = 0; int MultiplierOneQuaAftComma = 0;
int MultiplierTwoQua = 0; int MultiplierTwoQuaBefComma = 0; int MultiplierTwoQuaAftComma = 0;
int MaxBefComma = 0; int MaxAftComma = 0;
int index = 0;
if (!Logic)
{
if (!Serviсe.CheckNumber(MultiplierOne, MultiplierTwo))
{
return(false);
}
MultiplierOneQua = Serviсe.StringNumberQua(MultiplierOne);
MultiplierTwoQua = Serviсe.StringNumberQua(MultiplierTwo);
MultiplierOneM = new double[MultiplierOneQua];
MultiplierTwoM = new double[MultiplierTwoQua];
Serviсe.StringToMass(MultiplierOne, MultiplierOneM, MultiplierOneQua, MultiplierOneNegative);
Serviсe.StringToMass(MultiplierTwo, MultiplierTwoM, MultiplierTwoQua, MultiplierTwoNegative);
}
MultiplierOneQuaBefComma = Serviсe.NumberQuaBeforeComma(MultiplierOneM); MultiplierOneQuaAftComma = Serviсe.NumberQuaAfterComma(MultiplierOneM);
MultiplierTwoQuaBefComma = Serviсe.NumberQuaBeforeComma(MultiplierTwoM); MultiplierTwoQuaAftComma = Serviсe.NumberQuaAfterComma(MultiplierTwoM);
if (Logic)
{
MultiplierOneQua = MultiplierOneQuaBefComma + MultiplierOneQuaAftComma;
if (MultiplierOneQuaAftComma > 0)
{
MultiplierOneQua++;
}
MultiplierTwoQua = MultiplierTwoQuaBefComma + MultiplierTwoQuaAftComma;
if (MultiplierTwoQuaAftComma > 0)
{
MultiplierTwoQua++;
}
}
MaxBefComma = Serviсe.MaxNumber(MultiplierOneQuaBefComma, MultiplierTwoQuaBefComma);
MaxAftComma = Serviсe.MaxNumber(MultiplierOneQuaAftComma, MultiplierTwoQuaAftComma);
index = MaxAftComma + MaxBefComma;
if (MultiplierTwoQua > MultiplierOneQua)
{
MultiplierOneMtemp = new double[MultiplierTwoQua];
MultiplierTwoMtemp = new double[MultiplierOneQua];
MultiplierOneM.CopyTo(MultiplierTwoMtemp, 0);
MultiplierTwoM.CopyTo(MultiplierOneMtemp, 0);
MultiplierOneM = MultiplierOneMtemp;
MultiplierTwoM = MultiplierTwoMtemp;
TempInt = MultiplierOneQua;
MultiplierOneQua = MultiplierTwoQua;
MultiplierTwoQua = TempInt;
}
for (int i = MultiplierTwoM.Length - 1; i >= 0; i--)
{
memory = 0;
Stage1 = new Stage(MultiplierOneQua, MultiplierTwoQua, MultiplierOneQua);
if (MultiplierTwoM[i] == 0.5)
{
continue;
}
for (int u = MultiplierOneM.Length - 1, y = MultiplierOneM.Length - 1; u >= 0; u--)
{
if (MultiplierOneM[u] == 0.5)
{
continue;
}
if (MultiplierTwoM[i] != 0 || MultiplierOneM[u] != 0)
{
TempInt = (int)(MultiplierTwoM[i] * MultiplierOneM[u] + memory);
memory = 0;
}
else
{
TempInt = 0;
memory = 0;
}
if (TempInt > 9)
{
memory = TempInt / 10;
Stage1.Answer[y] = TempInt % 10;
if (y == 0 && u == 0)
{
MultiplierOneMtemp = new double[MultiplierOneQua + 1];
Stage1.Answer.CopyTo(MultiplierOneMtemp, 1);
MultiplierOneMtemp[0] = TempInt / 10;
Stage1.Answer = MultiplierOneMtemp;
break;
}
y--;
continue;
}
Stage1.Answer[y] = TempInt;
y--;
}
StageMultiplication.Add(Stage1);
}
if (StageMultiplication.Count > 1)
{
TempInt = StageMultiplication.Count - 1;
counter = TempInt;
LogicSw = 0;
Stage1 = new Stage(MultiplierOneQua, MultiplierTwoQua, MultiplierOneQua);
Stage1.Answer = StageMultiplication[0].Answer;
for (int i = 0; i < TempInt; i++)
{
if (LogicSw == 0)
{
if (StageMultiplication[i].Answer.Length != StageMultiplication[i + 1].Answer.Length)
{
counter++;
}
LogicSw = 1;
MultiplierOneMtemp = new double[MultiplierOneQua + counter];
MultiplierTwoMtemp = new double[MultiplierOneQua + counter];
StageMultiplication[i].Answer.CopyTo(MultiplierOneMtemp, MultiplierOneQua + counter - StageMultiplication[i].Answer.Length);
StageMultiplication[i + 1].Answer.CopyTo(MultiplierTwoMtemp, MultiplierOneQua + counter - StageMultiplication[i + 1].Answer.Length - (i + 1));
Add = new Addition(MultiplierOneMtemp, MultiplierTwoMtemp);
if (Add.Calculate())
{
Stage1.Answer = Add.StageAdd[0].Answer;
}
continue;
}
if (LogicSw == 1)
{
if (Stage1.Answer.Length != MultiplierOneQua + counter)
{
counter++;
}
MultiplierOneMtemp = new double[MultiplierOneQua + counter];
MultiplierTwoMtemp = new double[MultiplierOneQua + counter];
Stage1.Answer.CopyTo(MultiplierOneMtemp, MultiplierOneQua + counter - Stage1.Answer.Length);
StageMultiplication[i + 1].Answer.CopyTo(MultiplierTwoMtemp, MultiplierOneQua + counter - StageMultiplication[i + 1].Answer.Length - (i + 1));
Add = new Addition(Stage1.Answer, MultiplierTwoMtemp);
if (Add.Calculate())
{
Stage1.Answer = Add.StageAdd[0].Answer;
}
continue;
}
}
if (MultiplierOneNegative && !MultiplierTwoNegative || !MultiplierOneNegative && MultiplierTwoNegative)
{
Stage1.AnswerNegative = true;
}
StageMultiplication.Add(Stage1);
StageMultiplication[0].NumberOne = MultiplierOneM;
StageMultiplication[0].NumberTwo = MultiplierTwoM;
}
return(true);
}
