public static string calculateIntervalExtended(FractionedNumber[] list, Number begin, Number end) { string res = ""; for(Number i = begin;i < end;i++) { res += i + ": \t"; res += calculateEquationPart(list, new FractionedNumber(i)); res += "\n"; } return res; }
public static string calculateInterval(FractionedNumber[] list, Number begin, Number end) { string res = ""; Number begin2 = begin; while(begin2 < end - 1) { BisectInterval bi = calculateBisectEquationBisectIntervals(list, begin2, end); begin2 = ((int) bi.End); if(begin2 >= end - 1) break; res += "a: " + bi.Begin; res += " b: " + bi.End; res += "\n"; } return res; }
public static FractionedNumber calculateBisectEquation(FractionedNumber[] list, FractionedNumber error, Number begin, Number end) { BisectTablePart lastTable = null; lastTable = calculateBisectEquationBisectTablePart(list, lastTable, begin, end); result += "Intervalo entre "+lastTable.BisectInterval.Begin; result += " e " + lastTable.BisectInterval.End; result += "\n"; while(lastTable.Error>error) { result+=lastTable.ToString()+"\n"; lastTable = calculateBisectEquationBisectTablePart(list, lastTable, begin, end); } result += lastTable.ToString() + "\n"; result += "\n"; result += "Resultado: "+lastTable.BisectInterval.Average; return lastTable.BisectInterval.Average; }
public static FractionedNumber calculateNewtonEquation(FractionedNumber[] list, FractionedNumber error, Number begin, Number end) { NewtonTablePart lastTable = null; FractionedNumber[] list2 = calculateNewtonList2(list); lastTable = calculateNewtonEquationTablePart(list, list2, lastTable, begin, end); result += "Número próximo a " + lastTable.X0; result += "\n"; while(lastTable.Error > error) { result += lastTable.ToString(); result += "\n"; lastTable = calculateNewtonEquationTablePart(list,list2, lastTable, begin, end); } result += lastTable.ToString(); result += "\n"; result += "Resultado: " + lastTable.X1; return lastTable.X1; }
private static void sumOut(FractionedNumber[] lines, FractionedNumber[] colums, bool[,] usedMatrix, FractionedNumber[,] costs, FractionedNumber[,] tempMatrix) { for(int l = 0;l < tempMatrix.GetLength(0);l++) { for(int c = 0;c < tempMatrix.GetLength(1);c++) { if(!usedMatrix[l, c]) { tempMatrix[l, c] = costs[l, c] - lines[l] - colums[c]; } else { tempMatrix[l, c] = null; } } } }
private static BisectTablePart calculateBisectEquationBisectTablePart(FractionedNumber[] list, BisectTablePart lastTable, Number begin, Number end) { BisectTablePart table = new BisectTablePart(); if(lastTable != null) { if(lastTable.ResInterval.Begin.Numerator * lastTable.ResInterval.Average.Numerator < 0) { table.BisectInterval.Begin = lastTable.BisectInterval.Begin; table.BisectInterval.End = lastTable.BisectInterval.Average; table.ResInterval.Begin = lastTable.ResInterval.Begin; table.ResInterval.End = lastTable.ResInterval.Average; } else { table.BisectInterval.Begin = lastTable.BisectInterval.Average; table.BisectInterval.End = lastTable.BisectInterval.End; table.ResInterval.Begin = lastTable.ResInterval.Average; table.ResInterval.End = lastTable.ResInterval.End; } } else { table.BisectInterval = calculateBisectEquationBisectIntervals(list,begin,end); table.ResInterval.Begin = calculateEquationPart(list, table.BisectInterval.Begin); table.ResInterval.End = calculateEquationPart(list, table.BisectInterval.End); } table.BisectInterval.DoAverage(); table.ResInterval.Average = calculateEquationPart(list, table.BisectInterval.Average); if(lastTable != null) { if(table.BisectInterval.Average.Numerator == 0) table.Error = new FractionedNumber(0); else table.Error = (( table.BisectInterval.Average - lastTable.BisectInterval.Average) / table.BisectInterval.Average); if(table.Error.Numerator < 0) table.Error.Numerator = -table.Error.Numerator; } return table; }
private static FractionedNumber SumNumbers(FractionedNumber[] array) { FractionedNumber res = 0; for(int i = 0;i < array.Length;i++) { res += array[i]; } return res; }
private static FractionedNumber[,] VogelFirstPart(FractionedNumber[,] costs, FractionedNumber[] demand, FractionedNumber[] supply) { verifyVogel(demand, supply, costs); Functions.result += "Matriz de custos de entrada:\n"; Functions.result += printMatrix(costs); Functions.result += "Supply de entrada:\n"; for(int i = 0;i < supply.Length;i++) { Functions.result += supply[i] + (i+1<supply.Length?", ":""); } Functions.result += "\nDemand de entrada:\n"; for(int i = 0;i < demand.Length;i++) { Functions.result += demand[i] + (i + 1 < demand.Length ? ", " : ""); } Functions.result += "\n----------------------------\n"; FractionedNumber[] demandRemaining = new FractionedNumber[demand.Length]; FractionedNumber[] supplyRemaining = new FractionedNumber[supply.Length]; FractionedNumber[,] result = new FractionedNumber[costs.GetLength(0), costs.GetLength(1)]; List<VogelPos> taxaDegeneracao = new List<VogelPos>(); Array.Copy(demand, demandRemaining, demand.Length); Array.Copy(supply, supplyRemaining, supply.Length); List<VogelPos> temp = new List<VogelPos>(); for (int l = 0; l < costs.GetLength(0); l++) { temp.Clear(); for (int c = 0; c < costs.GetLength(1); c++) { temp.Add(new VogelPos(l,c, costs[l, c],true)); } var n = temp.OrderBy(x => x.number); if(costs[n.ElementAt(0).x, n.ElementAt(0).y] < costs[n.ElementAt(1).x, n.ElementAt(1).y]) { taxaDegeneracao.Add(new VogelPos(n.ElementAt(0).x, n.ElementAt(0).y, n.ElementAt(1).number - n.ElementAt(0).number,true)); } else { taxaDegeneracao.Add(new VogelPos(n.ElementAt(1).x, n.ElementAt(1).y, n.ElementAt(0).number - n.ElementAt(1).number,true)); } } for(int c = 0;c < costs.GetLength(1);c++) { temp.Clear(); for(int l = 0;l < costs.GetLength(0);l++) { temp.Add(new VogelPos(l, c, costs[l, c],false)); } temp = temp.OrderBy(x => x.number).ToList(); if(costs[temp.ElementAt(0).x, temp.ElementAt(0).y] < costs[temp.ElementAt(1).x, temp.ElementAt(1).y]) { taxaDegeneracao.Add(new VogelPos(temp.ElementAt(0).x, temp.ElementAt(0).y, temp.ElementAt(1).number - temp.ElementAt(0).number,false)); } else { taxaDegeneracao.Add(new VogelPos(temp.ElementAt(1).x, temp.ElementAt(1).y, temp.ElementAt(0).number - temp.ElementAt(1).number,false)); } } Functions.result += "Taxa de degeneração: \n"; for(int i = 0;i < taxaDegeneracao.Count;i++) { Functions.result += taxaDegeneracao[i].number + " @ " + (taxaDegeneracao[i].x + 1) + "," + (taxaDegeneracao[i].y + 1) + (taxaDegeneracao[i].line?" linha ":" coluna ") + "\n"; } Functions.result += "---------- \n"; taxaDegeneracao = taxaDegeneracao.OrderBy(x => 0-x.number).ThenBy(x=>costs[x.x,x.y]).ToList(); Functions.result += "Taxa de degeneração ordenada: \n"; for(int i = 0;i < taxaDegeneracao.Count;i++) { Functions.result += taxaDegeneracao[i].number + " @ " + (taxaDegeneracao[i].x + 1) + "," + (taxaDegeneracao[i].y + 1) + (taxaDegeneracao[i].line ? " linha " : " coluna ") + "\n"; } Functions.result += "---------- \n"; //Respeita a ordem da taxa de degeneracao for(int i = 0;i < taxaDegeneracao.Count;i++) { int l = taxaDegeneracao[i].x; int c = taxaDegeneracao[i].y; FractionedNumber min = long.MaxValue; FractionedNumber minSupplyDemand; if(taxaDegeneracao[i].line) { for(int j = 0;j < costs.GetLength(1);j++) { if(costs[l, j] < min) { if(supply[l] > 0 && demand[j] > 0) { min = costs[l, j]; c = j; } } } } else { for(int j = 0;j < costs.GetLength(0);j++) { if(costs[j, c] < min) { if(supply[j] > 0 && demand[c] > 0) { min = costs[j, c]; l = j; } } } } if(supply[l] == 0 || demand[c] == 0) continue; minSupplyDemand = FractionedNumber.Min(supply[l], demand[c]); supply.SetValue(supply.ElementAt(l) - minSupplyDemand, l); demand.SetValue(demand.ElementAt(c) - minSupplyDemand, c); result[l, c] = minSupplyDemand; } temp.Clear(); for(int l = 0;l < costs.GetLength(0);l++) { for(int c = 0;c < costs.GetLength(1);c++) { temp.Add(new VogelPos(l, c, costs[l, c],false)); } } temp = temp.OrderBy(x => x.number).ToList(); for(int i = 0;i < temp.Count;i++) { if(supply[temp[i].x] > 0) { if(demand[temp[i].y] > 0){ FractionedNumber min = FractionedNumber.Min(supply[temp[i].x], demand[temp[i].y]); result[temp[i].x, temp[i].y] = min; supply[temp[i].x] -= min; demand[temp[i].y] -= min; } } } Functions.result += "Matriz antes de fazer a segunda parte:\n"; Functions.result += printMatrix(result); Functions.result += "-------------------------------\n"; return result; }
private static FractionedNumber[,] VogelSecondPart(FractionedNumber[,] costs, FractionedNumber[] demand, FractionedNumber[] supply, FractionedNumber[,] matrix) { VogelPos min; int count = 1; do { min = new VogelPos(-1, -1, long.MaxValue, false); FractionedNumber[,] res = new FractionedNumber[matrix.GetLength(0), matrix.GetLength(1)]; bool[,] usedMatrix = GetMatrixInsideVogel(matrix); bool[,] usedMatrix2 = new bool[usedMatrix.GetLength(0), usedMatrix.GetLength(1)]; System.Array.Copy(usedMatrix, usedMatrix2, usedMatrix.Length); FractionedNumber[,] tempMatrix = new FractionedNumber[matrix.GetLength(0), matrix.GetLength(1)]; Functions.result += "=============================\n"; Functions.result += "Iteração "+count+"\n"; Functions.result += "=============================\n"; FractionedNumber[] lines = new FractionedNumber[matrix.GetLength(0)]; FractionedNumber[] colums = new FractionedNumber[matrix.GetLength(1)]; goLine(-1, -1, 0, tempMatrix, costs, usedMatrix2, lines, colums); bool erroL = false; bool erroC = false; for(int i = 0;i < lines.Length;i++) { if(lines[i] == null) erroL = true; } for(int i = 0;i < colums.Length;i++) { if(colums[i] == null) erroC = true; } if(erroL || erroC) { min.number = -1; Functions.result += "=============================\n"; Functions.result += "Não foi possível colocar valores em todas as linhas e colunas.\n"; Functions.result += "Deve-se criar uma variável artificial.\n"; int posX = -1; int posY = -1; if(erroL){ for(int i = 0;i < lines.Length;i++) { if(lines[i] == null) { for(int j = 0;j < matrix.GetLength(1);j++) { if(matrix[i, j] == null) { posX = i; posY = j; break; } } break; } } } else { for(int i = 0;i < colums.Length;i++) { if(colums[i] == null) { for(int j = 0;j < matrix.GetLength(0);j++) { if(matrix[j, i] == null) { posX = i; posY = j; break; } } break; } } } matrix[posX, posY] = 0; Functions.result += "Ela foi colocada em: L"+(posX+1)+", C"+(posY+1)+"\n"; Functions.result += "=============================\n"; continue; } for(int i = 0;i < lines.Length;i++) { Functions.result += "L" + (i + 1) + ":" + lines[i] + ", \t"; } Functions.result += "\n"; for(int i = 0;i < colums.Length;i++) { Functions.result += "C" + (i + 1) + ":" + colums[i] + ", \t"; ; } Functions.result += "\n\n"; Functions.result += "Matriz dentro:\n"; Functions.result += printMatrix(tempMatrix); Functions.result += "-------------------------\n"; sumOut(lines, colums, usedMatrix, costs, tempMatrix); Functions.result += "Matriz fora:\n"; Functions.result += printMatrix(tempMatrix); Functions.result += "-------------------------\n"; for(int l = 0;l < tempMatrix.GetLength(0);l++) { for(int c = 0;c < tempMatrix.GetLength(1);c++) { if(tempMatrix[l, c] != null) { if(tempMatrix[l, c] < min.number) { min.y = c; min.x = l; min.number = tempMatrix[l, c]; } } } } Functions.result += "Valor mínimo: "+min.number+" na linha "+(min.x+1)+" e coluna "+(min.y+1)+"\n"; if(min.number < 0) { List<VogelPos> list = VogelFindWay(min, usedMatrix, matrix); if(list == null) break; FractionedNumber min2 = FractionedNumber.Min(list[0].number, list[list.Count - 1].number); Functions.result += "Minimo: " + min2 + "\n"; bool soma = false; for(int i = 0;i < list.Count;i++) { if(matrix[list[i].x, list[i].y] == null) matrix[list[i].x, list[i].y] = 0; if(soma) { matrix[list[i].x, list[i].y] += min2; } else { matrix[list[i].x, list[i].y] -= min2; } if(matrix[list[i].x, list[i].y] == 0) matrix[list[i].x, list[i].y] = null; soma = !soma; } matrix[min.x, min.y] += min2; Functions.result += "Fez a troca\n"; } Functions.result += "-------------------------\n"; Functions.result += "Matriz: \n"; Functions.result += "-------------------------\n"; Functions.result += printMatrix(matrix); Functions.result += "-------------------------\n"; count++; } while(min.number<0 && count <= 25); if(count > 20) { Functions.result += "***********************\n"; Functions.result += "Houve muitas iterações, algo está errado!\n"; Functions.result += "***********************\n"; } bool tirouArt = false; for(int l = 0;l < matrix.GetLength(0);l++) { for(int c = 0;c < matrix.GetLength(1);c++) { if(matrix[l, c] == 0) { matrix[l, c] = null; tirouArt = true; } } } if(tirouArt) { Functions.result += "Foram tiradas as variáveis artificiais, ficando assim:\n"; Functions.result += printMatrix(matrix); Functions.result += "-------------------------\n"; } return matrix; }
private static List<VogelPos> VogelFindWay(VogelPos destiny, bool[,] usedMatrix, FractionedNumber[,] matrix) { bool[,] usedMatrixTemp = new bool[usedMatrix.GetLength(0),usedMatrix.GetLength(1)]; Array.Copy(usedMatrix, usedMatrixTemp, usedMatrix.Length); List<VogelPos> list = new List<VogelPos>(); if(VogelFindWayLine(list, destiny, usedMatrixTemp, destiny, matrix)) { Functions.result += "Caminho encontrado:\n"; for(int i = 0;i < list.Count;i++) { Functions.result += "[" + (list[i].x + 1) + ", " + (list[i].y + 1) + "] "; } Functions.result += "\n"; return list; } else { Functions.result += "++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"; Functions.result += "Não encontrou caminho. ERRO!\n"; Functions.result += "++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"; } return null; }
private static bool VogelFindWayLine(List<VogelPos> list, VogelPos destiny, bool[,] usedMatrix, VogelPos now, FractionedNumber[,] matrix) { for(int y = 0;y < usedMatrix.GetLength(1);y++) { if(y == destiny.y && usedMatrix[now.x,y]) { VogelPos v = new VogelPos(now.x, y, matrix[now.x, y], true); usedMatrix[v.x, v.y] = false; list.Add(v); return true; } if(usedMatrix[now.x, y]) { VogelPos v = new VogelPos(now.x, y, matrix[now.x,y], true); usedMatrix[v.x, v.y] = false; list.Add(v); if(VogelFindWayColum(list,destiny,usedMatrix,v,matrix)){ return true; } list.Remove(v); } } return false; }
private static bool[,] GetMatrixInsideVogel(FractionedNumber[,] matrix) { bool[,] res = new bool[matrix.GetLength(0), matrix.GetLength(1)]; for (int l = 0; l < matrix.GetLength(0); l++) { for (int c = 0; c < matrix.GetLength(1); c++) { if (matrix[l, c] != null) res[l, c] = true; else res[l, c] = false; } } return res; }
private static void goColum(int x, int y, FractionedNumber v, FractionedNumber[,] m, FractionedNumber[,] costs, bool[,] usedMatrix, FractionedNumber[] lines, FractionedNumber[] colums) { for(int i = 0;i < m.GetLength(0);i++) { if(i == x) continue; if(usedMatrix[i,y]) { m[i,y] = 0 - v + costs[i,y]; if(lines[i] == null) lines[i] = m[i, y]; usedMatrix[i,y] = false; goLine(i,y, m[i,y], m, costs, usedMatrix, lines, colums); } } }
private static FractionedNumber[,] CalculateVogelInternalMatrix(FractionedNumber[,] matrix) { return null; }
private static FractionedNumber[] computeDividedDifference(FractionedNumber[] x, FractionedNumber[] y) { FractionedNumber[] divdiff = new FractionedNumber[y.Length]; y.CopyTo(divdiff, 0); int n = x.Length; FractionedNumber[] a = new FractionedNumber [n]; a[0] = divdiff[0]; for (int i = 1; i < n; i++) { for (int j = 0; j < n-i; j++) { FractionedNumber denominator = x[j+i] - x[j]; divdiff[j] = (divdiff[j+1] - divdiff[j]) / denominator; } a[i] = divdiff[0]; } return a; }
private static FractionedNumber[] calculateNewtonList2(FractionedNumber[] list) { FractionedNumber[] list2 = new FractionedNumber[list.Length - 1]; for(int i = 1;i < list.Length;i++) { list2[i - 1] = list[i] * new FractionedNumber(i); } return list2; }
private static NewtonTablePart calculateNewtonEquationTablePart(FractionedNumber[] list1, FractionedNumber[] list2, NewtonTablePart lastTable, Number begin, Number end) { NewtonTablePart table = new NewtonTablePart(); if(lastTable == null) { table.X0 = calculateNewtonEquationMin(list1, begin, end); } else { table.X0 = lastTable.X1; } table.FX = calculateEquationPart(list1, table.X0); table.FLX = calculateEquationPart(list2, table.X0); table.X1 = table.X0 - (table.FX/table.FLX); table.Error = (table.X1 - table.X0) / table.X1; if(table.Error < new FractionedNumber(0)) { table.Error = table.Error * new FractionedNumber(-1); } return table; }
private static FractionedNumber calculateEquationPart(FractionedNumber[] list, FractionedNumber number) { FractionedNumber res = new FractionedNumber(0); for(int i = 0;i < list.Length;i++) { FractionedNumber resTemp = new FractionedNumber(1); for(int j = 0;j < i;j++) { resTemp *= number; } resTemp *= list[i]; res += resTemp; } return res; }
private static void verifyVogel(FractionedNumber[] demand, FractionedNumber[] supply, FractionedNumber[,] matrix) { if(matrix.GetLength(1) != demand.Length || matrix.GetLength(0) != supply.Length) { string msg = "The demand and supply array doesn't have the same size of the matix\n"; msg += "demand["+demand.Length+"], supply["+supply.Length+"], costs["+matrix.GetLength(0)+","+matrix.GetLength(1)+"]"; throw new Exception(msg); } FractionedNumber sumSupply = SumNumbers(supply); FractionedNumber sumDemand = SumNumbers(demand); if(sumSupply != sumDemand) { string msg = "The sums of the supply and demand are differents!\n"; msg += "Supply sum: " + sumSupply + ", Demand sum: " + sumDemand+"\n"; msg += "You need to insert a new "; if(sumSupply > sumDemand) msg += "demand (row bellow)"; else msg += "supply (colum on right)"; msg += " with the value " + (FractionedNumber.Max(sumDemand, sumSupply) - FractionedNumber.Min(sumDemand, sumSupply)); throw new Exception(msg); } }
private static void goLine(int x, int y, FractionedNumber v, FractionedNumber[,] m, FractionedNumber[,] costs, bool[,] usedMatrix, FractionedNumber[] lines, FractionedNumber[] colums) { if(x == -1 && y == -1) { lines[0] = 0; } for(int i = 0;i < m.GetLength(1);i++) { if(i == y) continue; if((x == -1 && y == -1) || usedMatrix[x,i]) { if(x == -1 && y == -1) { if(usedMatrix[0, i]) { m[0, i] = 0 - v + costs[0, i]; if(colums[i] == null) colums[i] = m[0, i]; usedMatrix[0, i] = false; goColum(0, i, m[0, i], m, costs, usedMatrix, lines, colums); } } else { m[x, i] = 0 - v + costs[x, i]; if(colums[i] == null) colums[i] = m[x, i]; usedMatrix[x, i] = false; goColum(x, i, m[x, i], m, costs, usedMatrix, lines, colums); } } } }
private static FractionedNumber VogelCalculateTotalCost(FractionedNumber[,] matrix, FractionedNumber[,] costs) { result += "Total cost: "; FractionedNumber sum = 0; for(int l = 0;l < matrix.GetLength(0);l++) { for(int c = 0;c < matrix.GetLength(1);c++) { sum += matrix[l, c] * costs[l, c]; } } result += sum; result += "\n"; return sum; }
private static FractionedNumber[,] NorthWestFirstPart(FractionedNumber[,] costs, FractionedNumber[] demand, FractionedNumber[] supply) { verifyVogel(demand, supply, costs); Functions.result += "Matriz de custos de entrada:\n"; Functions.result += printMatrix(costs); Functions.result += "Supply de entrada:\n"; for(int i = 0;i < supply.Length;i++) { Functions.result += supply[i] + (i + 1 < supply.Length ? ", " : ""); } Functions.result += "\nDemand de entrada:\n"; for(int i = 0;i < demand.Length;i++) { Functions.result += demand[i] + (i + 1 < demand.Length ? ", " : ""); } Functions.result += "\n----------------------------\n"; FractionedNumber[] demandRemaining = new FractionedNumber[demand.Length]; FractionedNumber[] supplyRemaining = new FractionedNumber[supply.Length]; FractionedNumber[,] result = new FractionedNumber[costs.GetLength(0), costs.GetLength(1)]; Array.Copy(demand, demandRemaining, demand.Length); Array.Copy(supply, supplyRemaining, supply.Length); int posL = 0; int posC = 0; while(demandRemaining[posC]!=0 && supplyRemaining[posL]!=0) { FractionedNumber min = FractionedNumber.Min(demandRemaining[posC], supplyRemaining[posL]); result[posL, posC] = min; demandRemaining[posC] -= min; supplyRemaining[posL] -= min; if(supplyRemaining[posL] == 0) { if(supplyRemaining.Length!=posL+1) posL++; } if(demandRemaining[posC] == 0) { if(demandRemaining.Length != posC + 1) posC++; } } Functions.result += "Matriz antes de fazer a segunda parte:\n"; Functions.result += printMatrix(result); Functions.result += "-------------------------------\n"; return result; }
private static bool VogelFindWayColum(List<VogelPos> list, VogelPos destiny, bool[,] usedMatrix, VogelPos now, FractionedNumber[,] matrix) { for(int x = 0;x < usedMatrix.GetLength(0);x++) { if(x == destiny.x && usedMatrix[x, now.y]) { return true; } if(usedMatrix[x, now.y]) { VogelPos v = new VogelPos(x, now.y, matrix[x, now.y], true); usedMatrix[v.x, v.y] = false; list.Add(v); if(VogelFindWayLine(list, destiny, usedMatrix, v, matrix)) { return true; } list.Remove(v); } } return false; }
public static FractionedNumber[,] VogelApproximationMethod(FractionedNumber[,] costs, FractionedNumber[] demand, FractionedNumber[] supply, string path) { clearResult(); FractionedNumber[,] res = VogelFirstPart(costs, demand, supply); res = VogelSecondPart(costs, demand, supply, res); Functions.result += "\n-------------------\n"; VogelCalculateTotalCost(res, costs); writeFile(path); System.Console.WriteLine("Output to "+path); return res; }
public static FractionedNumber[,] VogelInverseMatrix(FractionedNumber[,] matrix) { FractionedNumber max = long.MinValue; FractionedNumber[,] newMatrix = new FractionedNumber[matrix.GetLength(0), matrix.GetLength(1)]; for(int l = 0;l < matrix.GetLength(0);l++) { for(int c = 0;c < matrix.GetLength(1);c++) { max = FractionedNumber.Max(max, matrix[l, c]); } } for(int l = 0;l < matrix.GetLength(0);l++) { for(int c = 0;c < matrix.GetLength(1);c++) { newMatrix[l, c] = max - matrix[l, c]; } } return newMatrix; }
private static FractionedNumber permutationR(FractionedNumber[] n, int qt, int i, FractionedNumber sum, FractionedNumber sumPart, int ignore) { for(int j = i;j < n.Length-(qt-i);j++) { sumPart *= permutationR(n, qt-1, j, sum, sumPart, ignore); } return sum+sumPart; }
public static FractionedNumber calculateNewtonEquation(FractionedNumber[] list, FractionedNumber error) { return calculateNewtonEquation(list, error, -10000, 10000); }
private static string printMatrix(FractionedNumber[,] m) { string s = ""; for(int l = 0;l < m.GetLength(0);l++) { for(int c = 0;c < m.GetLength(1);c++) { s += (m[l, c] + "\t|"); } s += "\n"; } return s; }
public static FractionedNumber permutation(FractionedNumber[] n, int qt, int ignore) { FractionedNumber sum = permutationR(n, qt, 0,new FractionedNumber(0), new FractionedNumber(1), ignore); return sum; }
private static BisectInterval calculateBisectEquationBisectIntervals(FractionedNumber[] list, Number begin, Number end) { BisectInterval BisectInterval = new BisectInterval(); BisectInterval.Begin = new FractionedNumber(begin); BisectInterval.End = new FractionedNumber(end); FractionedNumber tmp = calculateEquationPart(list, new FractionedNumber(begin)); if(tmp.Numerator == 0) { BisectInterval.Begin = new FractionedNumber(begin); BisectInterval.End = new FractionedNumber(end); } else if(tmp.Numerator < 0) { for(Number i = begin + 1;i < end;i++) { FractionedNumber n = calculateEquationPart(list, new FractionedNumber(i)); if(n.Numerator < 0) { BisectInterval.Begin = new FractionedNumber(i); } else if(n.Numerator == 0) { BisectInterval.Begin = new FractionedNumber(i); BisectInterval.End = new FractionedNumber(i); break; } else { BisectInterval.End = new FractionedNumber(i); break; } } } else { for(Number i = begin+1;i < end;i++) { FractionedNumber n = calculateEquationPart(list, new FractionedNumber(i)); if(n.Numerator > 0) { BisectInterval.Begin = new FractionedNumber(i); } else if(n.Numerator == 0) { BisectInterval.Begin = new FractionedNumber(i); BisectInterval.End = new FractionedNumber(i); break; } else { BisectInterval.End = new FractionedNumber(i); break; } } } return BisectInterval; }