// ========================================================================
public void LastInsert(Fraction x)
{
a[length] = x;
length++;
}
public static void ProcessMenu()
{
FractionArray list = new FractionArray();
Fraction X = new Fraction();
int[] result = new int[100];
int menu;
int length = 0;
int numerator;
int denominator;
int a;
MenuOutput();
Write("The total number of functions is currently: ");
int function = int.Parse(ReadLine());
Clear();
do
{
menu = SelectMenu(function);
int x;
Write("\n");
switch ((Menu)menu)
{
case Menu.Exit:
WriteLine("\n0. Enter {0} to exit\n", (int)Menu.Exit);
return;
case Menu.Input:
Clear();
WriteLine("\n1. Enter {0} to insert information\n", (int)Menu.Input);
list.ImportFromFile();
//list.Creat();
//list.GeneratorRandom();
break;
case Menu.Out:
Clear();
WriteLine("\n2. Enter {0} to display array of fractions\n", (int)Menu.Out);
list.Output();
break;
case Menu.FindMax:
Clear();
WriteLine("\n3. Enter {0} to find max value\n", (int)Menu.FindMax);
list.FindMax().Output();
Write(" is max value");
break;
case Menu.FindDenominator_X:
Clear();
WriteLine("\n4. Enter {0} to find fractions with the same denominator\n", (int)Menu.FindDenominator_X);
list.Output();
Write("\nEnter denominator X to find: ");
list.FindSameDenominator_X(int.Parse(ReadLine())).Output();
break;
case Menu.CountNegativeFractions:
Clear();
WriteLine("\n5. Enter {0} to count negative fractions\n", (int)Menu.CountNegativeFractions);
WriteLine("\nNegative fraction array...");
list.CountNegativeFractions().Output();
WriteLine("\nThere is {0} negative faction in array", list.CountNegativeFractions().length);
break;
case Menu.CountPositiveFractions:
Clear();
WriteLine("\n6. Enter {0} to count positive fractions", (int)Menu.CountPositiveFractions);
WriteLine("\nPositive fraction array...");
list.CountPositiveFractions().Output();
WriteLine("\nThere is {0} positive faction in array", list.CountPositiveFractions().length);
break;
case Menu.CountNumerator_X:
Clear();
WriteLine("\n7. Enter {0} to count fractions with numerator X in array", (int)Menu.CountNumerator_X);
list.Output();
Write("\nEnter numerator X to count: ");
x = int.Parse(ReadLine());
list.CountNumerator_X(x).Output();
WriteLine("\nThere is {0} fractions have numerator is {1} in array", list.CountNumerator_X(x).length, x);
break;
case Menu.CountNumerator_Y:
Clear();
WriteLine("\n8. Enter {0} to count fractions with numerator Y in array", (int)Menu.CountNumerator_Y);
list.Output();
Write("\nEnter numerator Y to count: ");
x = int.Parse(ReadLine());
list.CountNumerator_X(x).Output();
WriteLine("\nThere is {0} fractions have numerator is {1} in array", list.CountNumerator_X(x).length, x);
break;
case Menu.FindNegativeFractionMax:
Clear();
WriteLine("\n9. Enter {0} to find the biggest negative fraction", (int)Menu.FindNegativeFractionMax);
list.Output();
WriteLine("\nNegative array...");
list.CountNegativeFractions().Output();
WriteLine("\nThe largest negative fraction in array is {0}", list.CountNegativeFractions().FindMax());
break;
case Menu.FindNegativeFractionMin:
Clear();
WriteLine("\n10. Enter {0} to find the smallest negative fraction", (int)Menu.FindNegativeFractionMin);
list.Output();
WriteLine("\nNegative array...");
list.CountNegativeFractions().Output();
WriteLine("\nThe largest negative fraction in array is {0}", list.CountNegativeFractions().FindMin());
break;
case Menu.FindPositiveFractionMax:
Clear();
WriteLine("\n11. Enter {0} to find the biggest positive fraction", (int)Menu.FindPositiveFractionMax);
list.Output();
WriteLine("\nPositive array...");
list.CountPositiveFractions().Output();
WriteLine("\nThe largest negative fraction in array is {0}", list.CountPositiveFractions().FindMax());
break;
case Menu.FindPositiveFractionMin:
Clear();
WriteLine("\n12. Enter {0} to find the biggest positive fraction", (int)Menu.FindPositiveFractionMin);
list.Output();
WriteLine("\nPositive array...");
list.CountPositiveFractions().Output();
WriteLine("\nThe largest negative fraction in array is {0}", list.CountPositiveFractions().FindMin());
break;
case Menu.FindAllNegativeFractions:
Clear();
WriteLine("\n13. Enter {0} to find all negative element in array", (int)Menu.FindAllNegativeFractions);
list.Output();
WriteLine("\nNegative array...");
list.CountNegativeFractions().Output();
break;
case Menu.FindAllPositiveFractions:
Clear();
WriteLine("\n14. Enter {0} to find all positive element in array", (int)Menu.FindAllPositiveFractions);
list.Output();
WriteLine("\nPositive array...");
list.CountPositiveFractions().Output();
break;
case Menu.FindAllLocationX:
Clear();
WriteLine("\n15. Enter {0} to find all positive of x in array", (int)Menu.FindAllLocationX);
list.Output();
WriteLine("\nEnter X to find all positive of x in array...");
X.Creat();
length = 0;
result = list.FindAllLocationX(X, ref length);
if (length == 0)
{
WriteLine("\nThere is no fraction X in array");
}
else
{
WriteLine("\nArray of location X...");
for (int i = 0; i < length; i++)
{
Write(result[i] + "\t");
}
}
break;
case Menu.FindFractionsLocation_Negative_Positive:
Clear();
WriteLine("\n16. Enter {0} to find position of negative and positive fractions in array", (int)Menu.FindFractionsLocation_Negative_Positive);
list.Output();
length = 0;
result = list.FindNegativeLocation(ref length);
WriteLine("\nArray of negative frations...");
for (int i = 0; i < length; i++)
{
Write(result[i] + "\t");
}
Array.Clear(result, 0, result.Length);
length = 0;
result = list.FindPositiveLocation(ref length);
WriteLine("\nArray of positive fractions...");
for (int i = 0; i < length; i++)
{
Write(result[i] + "\t");
}
break;
case Menu.SumOfNegativeFraction:
Clear();
WriteLine("\n17. Enter {0} to sum all negative fractions in the array", (int)Menu.SumOfNegativeFraction);
list.Output();
WriteLine("\nNegative array...");
list.CountNegativeFractions().Output();
WriteLine("\nSum all negative fractions in the array is {0}", list.CountNegativeFractions().Sum());
break;
case Menu.SumOfPositiveFraction:
Clear();
WriteLine("\n18. Enter {0} to sum all positive fractions in the array", (int)Menu.SumOfPositiveFraction);
list.Output();
WriteLine("\npositive array...");
list.CountPositiveFractions().Output();
WriteLine("\nSum all positive fractions in the array is {0}", list.CountPositiveFractions().Sum());
break;
case Menu.SumOfFractionsNumeratorX:
Clear();
WriteLine("\n19. Enter {0} to sum all fractions with the numerator x", (int)Menu.SumOfFractionsNumeratorX);
list.Output();
WriteLine("\nEnter the numerator x to calculate the sum: ");
x = int.Parse(ReadLine());
list.FindNumeratorX(x);
if (list.FindNumeratorX(x).length == 0)
{
WriteLine("\nThere is no fraction with the numerator x in the array");
}
else
{
WriteLine("\nArray with numerator {0}...", x);
list.FindNumeratorX(x).Output();
WriteLine("\nThe total value of the resulting array is {0}", list.FindNumeratorX(x).Sum());
}
break;
case Menu.SumOfFractionsDenominatorX:
Clear();
WriteLine("\n20. Enter {0} to sum all fractions with the denominator x", (int)Menu.SumOfFractionsDenominatorX);
list.Output();
WriteLine("\nEnter the denominator x to calculate the sum: ");
x = int.Parse(ReadLine());
list.FindDenominatorX(x);
if (list.FindDenominatorX(x).length == 0)
{
WriteLine("\nThere is no fraction with the denominator x in the array");
}
else
{
WriteLine("\nArray with denominator {0}...", x);
list.FindDenominatorX(x).Output();
WriteLine("\nThe total value of the resulting array is {0}", list.FindDenominatorX(x).Sum());
}
break;
case Menu.DelAtLocation:
Clear();
WriteLine("\n21. Enter {0} to delete at location in array", (int)Menu.DelAtLocation);
list.Output();
Write("\nEnter location to delete: ");
if (list.DeleteAt(int.Parse(ReadLine())))
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nThe location to be deleted is not valid");
}
break;
case Menu.DelAtFirstLocation:
Clear();
WriteLine("\n22. Enter {0} to delete at first location in array", (int)Menu.DelAtFirstLocation);
list.Output();
list.DeleteAt(0);
WriteLine("\nNew array...");
list.Output();
break;
case Menu.DelAtLastLocation:
Clear();
WriteLine("\n23. Enter {0} to delete at last location in array", (int)Menu.DelAtLastLocation);
list.Output();
list.DeleteAt(list.length);
WriteLine("\nNew array...");
list.Output();
break;
case Menu.DelFractionX:
Clear();
WriteLine("\n24. Enter {0} to delete fraction x in array", (int)Menu.DelFractionX);
list.Output();
WriteLine("\nEnter fraction x to delete: ");
X.Creat();
if (list.DeleteX(X))
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nThere is no fraction {0} in the array", X);
}
break;
case Menu.DelFractionNumeratorX:
Clear();
WriteLine("\n25. Enter {0} to delete fraction with numerator x in array", (int)Menu.DelFractionNumeratorX);
list.Output();
Write("\nEnter numerator x will be deleted: ");
numerator = int.Parse(ReadLine());
if (list.DelFractionNumeratorX(numerator))
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nThere is no numerator {0} in the array", numerator);
}
break;
case Menu.DelFractionDenominatorX:
Clear();
WriteLine("\n26. Enter {0} to delete fraction with denominator x in array", (int)Menu.DelFractionDenominatorX);
list.Output();
Write("\nEnter denominator x will be deleted: ");
denominator = int.Parse(ReadLine());
if (list.DelFractionDenominatorX(denominator))
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nThere is no numerator {0} in the array", denominator);
}
break;
case Menu.DelLikeFirstElement:
Clear();
WriteLine("\n27. Enter {0} to delete all fractions with the same value as the first fraction in the array", (int)Menu.DelLikeFirstElement);
list.Output();
list.DelLikeTheFirst();
WriteLine("\nNew array...");
list.Output();
break;
case Menu.DelLikeLastElement:
Clear();
WriteLine("\n28. Enter {0} to delete all fractions with the same value as the last fraction in the array", (int)Menu.DelLikeLastElement);
list.Output();
list.DelLikeTheLast();
WriteLine("\nNew array...");
list.Output();
break;
case Menu.DelAllFractionMin:
Clear();
WriteLine("\n29. Enter {0} to delete all smallest fractions", (int)Menu.DelAllFractionMin);
list.Output();
WriteLine("\nThe smallest fraction in the array is " + list.FindMin());
WriteLine("\nNew array...");
list.DeleteX(list.FindMin());
list.Output();
break;
case Menu.DelMultiLocation:
Clear();
WriteLine("\n30. Enter {0} to delete multiple locations", (int)Menu.DelMultiLocation);
list.Output();
WriteLine("\nEnter the position number to delete: ");
a = int.Parse(ReadLine());
for (int i = 0; i < a; i++)
{
Write("Location {0} = ", i);
result[i] = int.Parse(ReadLine());
}
list.DelArrayAt(result, a);
WriteLine("\nArray new...");
list.Output();
break;
case Menu.AddAtLocation:
Clear();
WriteLine("31. Enter {0} to add fraction at location", (int)Menu.AddAtLocation);
list.Output();
WriteLine("\nEnter the fraction x to insert: ");
X.Creat();
Write("\nEnter a location to insert: ");
if (list.InsertAt(X, int.Parse(ReadLine())))
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nThe position to be inserted is not valid!");
}
break;
case Menu.AddAtFirstLocation:
Clear();
WriteLine("\n32. Enter {0} to add fraction at first location", (int)Menu.AddAtFirstLocation);
list.Output();
WriteLine("\nEnter the fraction x to insert: ");
X.Creat();
if (list.InsertAt(X, 0))
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nSomething wrong!");
}
break;
case Menu.DelNegativeFraction:
Clear();
WriteLine("\n33. Enter {0} to delete negative fractions array", (int)Menu.DelNegativeFraction);
list.Output();
if (list.DelNegativeFraction())
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nArray without negative fractions!");
}
break;
case Menu.DelPositiveFraction:
Clear();
WriteLine("\n34. Enter {0} to delete positive fractions array", (int)Menu.DelPositiveFraction);
list.Output();
if (list.DelPositiveFraction())
{
WriteLine("\nNew array...");
list.Output();
}
else
{
WriteLine("\nArray without positive fractions!");
}
break;
case Menu.Sort:
Clear();
WriteLine("35. Enter {0} to sort", (int)Menu.Sort);
WriteLine("\nCurrent Array...");
list.Output();
WriteLine("\nSort up...");
list.SortUp();
list.Output();
WriteLine("\nSort increments by numerator...");
list.SortUpNumerator();
list.Output();
WriteLine("\nSort increments by denominator...");
list.SortUpDenominator();
list.Output();
WriteLine("\nSort down...");
list.SortDown();
list.Output();
WriteLine("\nSort descending by numerator...");
list.SortDownNumerator();
list.Output();
WriteLine("\nSort descending by denominator...");
list.SortDownDenominator();
list.Output();
break;
default:
break;
}
ReadLine();
} while (menu > 0);
}
public static float Tinh_GT(Fraction a)
{
return((float)a.numerator / a.denominator);
}