| public static Solve ( float M ) : bool | ||
| M | float | /// The system of linear equations as an augmented matrix[row, col] where (rows + 1 == cols). /// It will contain the solution in "row canonical form" if the function returns "true". /// |
| return | bool | |
public void Solve()
{
Matrix coefficients = new Matrix(NUnknown.Value, NUnknown.Value);
for (int i = 0; i != CoefficientMatrix.Count; ++i)
{
for (int j = 0; j != CoefficientMatrix[i].Count; ++j)
{
coefficients[i, j] = CoefficientMatrix[i][j].Val;
}
}
//xxx check for nulls
double[] b = BVector.Select(x => x.Val).ToArray();
double[] solution;
bool success = _model.Solve(coefficients, b, out solution);
if (success)
{
var builder = new StringBuilder();
for (int i = 0; i != solution.Length; ++i)
{
builder.Append(Unknowns[i] + " = " + solution[i] + "\n");
}
SolutionText = builder.ToString();
}
else
{
SolutionText = "Singular coefficient matrix";
}
}
public void LinearEquationSolverTest()
{
LinearEquationSolver solver = new LinearEquationSolver();
solver.AddEquation("3x+2y-z=1");
solver.AddEquation("2x-2y+4z=-2");
solver.AddEquation("-x+0.5y-z=0");
solver.Solve();
}
private void Solve()
{
if (bSolved || iPtr == 0)
{
return;
}
daSimEqn[0, 0] = get_sum_x(8);
daSimEqn[0, 1] = get_sum_x(7);
daSimEqn[0, 2] = get_sum_x(6);
daSimEqn[0, 3] = get_sum_x(5);
daSimEqn[0, 4] = get_sum_x(4);
daSimEqn[0, 5] = get_sum_xy(4);
daSimEqn[1, 0] = get_sum_x(7);
daSimEqn[1, 1] = get_sum_x(6);
daSimEqn[1, 2] = get_sum_x(5);
daSimEqn[1, 3] = get_sum_x(4);
daSimEqn[1, 4] = get_sum_x(3);
daSimEqn[1, 5] = get_sum_xy(3);
daSimEqn[2, 0] = get_sum_x(6);
daSimEqn[2, 1] = get_sum_x(5);
daSimEqn[2, 2] = get_sum_x(4);
daSimEqn[2, 3] = get_sum_x(3);
daSimEqn[2, 4] = get_sum_x(2);
daSimEqn[2, 5] = get_sum_xy(2);
daSimEqn[3, 0] = get_sum_x(5);
daSimEqn[3, 1] = get_sum_x(4);
daSimEqn[3, 2] = get_sum_x(3);
daSimEqn[3, 3] = get_sum_x(2);
daSimEqn[3, 4] = get_sum_x(1);
daSimEqn[3, 5] = get_sum_xy(1);
daSimEqn[4, 0] = get_sum_x(4);
daSimEqn[4, 1] = get_sum_x(3);
daSimEqn[4, 2] = get_sum_x(2);
daSimEqn[4, 3] = get_sum_x(1);
daSimEqn[4, 4] = 1;
daSimEqn[4, 5] = get_sum_xy(0);
if (LinearEquationSolver.Solve(daSimEqn))
{
daTerm = daSimEqn[0, 5];
dbTerm = daSimEqn[1, 5];
dcTerm = daSimEqn[2, 5];
ddTerm = daSimEqn[3, 5];
deTerm = daSimEqn[4, 5];
}
}
public Plane GetFitPlane()
{
double[,] solvM = new double[3, 4];
foreach (Vector3 v in m_Points)
{
solvM[0, 0] += v.X * v.X;
solvM[0, 1] += v.X * v.Y;
solvM[0, 2] += v.X;
solvM[1, 0] += v.Y * v.X;
solvM[1, 1] += v.Y * v.Y;
solvM[1, 2] += v.Y;
solvM[2, 0] += v.X;
solvM[2, 1] += v.Y;
solvM[2, 2] += 1;
}
foreach (Vector3 v in m_Points)
{
solvM[0, 3] += v.X * v.Z;
solvM[1, 3] += v.Z * v.Z;
solvM[2, 3] += v.Z;
}
List <double> resultSolv = new List <double>();
Boolean okay = LinearEquationSolver.Solve(solvM, out resultSolv);
if (okay == true)
{
return(Plane.CreateFormFunctionXYCoefficient(resultSolv[0], resultSolv[1], resultSolv[2]));
}
else
{
return(null);
}
}
private void Solve()
{
mainToolStripStatusLabel.Text = Properties.Resources.IDS_SOLVING_EQUATIONS;
Sparse2DMatrix <int, int, double> aMatrix = new Sparse2DMatrix <int, int, double>();
SparseArray <int, double> bVector = new SparseArray <int, double>();
SparseArray <string, int> variableNameIndexMap = new SparseArray <string, int>();
int numberOfEquations = 0;
LinearEquationParser parser = new LinearEquationParser();
LinearEquationParserStatus parserStatus = LinearEquationParserStatus.Success;
foreach (string inputLine in equationsRichTextBox.Lines)
{
parserStatus = parser.Parse(inputLine,
aMatrix,
bVector,
variableNameIndexMap,
ref numberOfEquations);
if (parserStatus != LinearEquationParserStatus.Success)
{
break;
}
}
// Assume success.
string mainStatusBarText = Properties.Resources.IDS_EQUATIONS_SOLVED;
// Did an error occur?
if (parserStatus == LinearEquationParserStatus.Success)
{
// Are there the same number of equations as variables?
if (numberOfEquations == variableNameIndexMap.Count)
{
// Create a solution vector.
SparseArray <int, double> xVector = new SparseArray <int, double>();
// Solve the simultaneous equations.
LinearEquationSolverStatus solverStatus =
LinearEquationSolver.Solve(numberOfEquations,
aMatrix,
bVector,
xVector);
if (solverStatus == LinearEquationSolverStatus.Success)
{
string solutionString = "";
foreach (KeyValuePair <string, int> pair in variableNameIndexMap)
{
solutionString += string.Format("{0} = {1}", pair.Key, xVector[pair.Value]);
solutionString += "\n";
}
equationsRichTextBox.Text += "\n" + solutionString;
}
else if (solverStatus == LinearEquationSolverStatus.IllConditioned)
{
mainStatusBarText = Properties.Resources.IDS_ILL_CONDITIONED_SYSTEM_OF_EQUATIONS;
}
else if (solverStatus == LinearEquationSolverStatus.Singular)
{
mainStatusBarText = Properties.Resources.IDS_SINGULAR_SYSTEM_OF_EQUATIONS;
}
}
else if (numberOfEquations < variableNameIndexMap.Count)
{
mainStatusBarText = string.Format(Properties.Resources.IDS_TOO_FEW_EQUATIONS,
numberOfEquations, variableNameIndexMap.Count);
}
else if (numberOfEquations > variableNameIndexMap.Count)
{
mainStatusBarText = string.Format(Properties.Resources.IDS_TOO_MANY_EQUATIONS,
numberOfEquations, variableNameIndexMap.Count);
}
}
else
{
// An error occurred. Report the error in the status bar.
mainStatusBarText = LinearEquationParserStatusInterpreter.GetStatusString(parserStatus);
}
mainToolStripStatusLabel.Text = mainStatusBarText;
}
public string SolveEquation(string equation)
{
Sparse2DMatrix <int, int, double> aMatrix = new Sparse2DMatrix <int, int, double>();
SparseArray <int, double> bVector = new SparseArray <int, double>();
SparseArray <string, int> variableNameIndexMap = new SparseArray <string, int>();
int numberOfEquations = 0;
LinearEquationParser parser = new LinearEquationParser();
LinearEquationParserStatus parserStatus = LinearEquationParserStatus.Success;
string[] lines = equation.Split(new[] { "\r\n", "\r", "\n", "\\n", "," }, StringSplitOptions.None);
foreach (string inputLine in lines)
{
parserStatus = parser.Parse(inputLine,
aMatrix,
bVector,
variableNameIndexMap,
ref numberOfEquations);
if (parserStatus != LinearEquationParserStatus.Success)
{
break;
}
}
// Assume success.
string mainStatusBarText = "Equations solved";
// Did an error occur?
if (parserStatus == LinearEquationParserStatus.Success)
{
// Are there the same number of equations as variables?
if (numberOfEquations == variableNameIndexMap.Count)
{
// Create a solution vector.
SparseArray <int, double> xVector = new SparseArray <int, double>();
// Solve the simultaneous equations.
LinearEquationSolverStatus solverStatus =
LinearEquationSolver.Solve(numberOfEquations,
aMatrix,
bVector,
xVector);
if (solverStatus == LinearEquationSolverStatus.Success)
{
string solutionString = "";
foreach (KeyValuePair <string, int> pair in variableNameIndexMap)
{
solutionString += string.Format("{0} = {1}" + " ", pair.Key, xVector[pair.Value]);
}
return(solutionString);
}
else if (solverStatus == LinearEquationSolverStatus.IllConditioned)
{
mainStatusBarText = "Error - the system of equations is ill conditioned.";
}
else if (solverStatus == LinearEquationSolverStatus.Singular)
{
mainStatusBarText = "Error - the system of equations is singular.";
}
}
else if (numberOfEquations < variableNameIndexMap.Count)
{
mainStatusBarText = string.Format("Only {0} equations is too few equations for {1} variables", numberOfEquations, variableNameIndexMap.Count);
}
else if (numberOfEquations > variableNameIndexMap.Count)
{
mainStatusBarText = string.Format("{0} equations is too many equations for only {1} variables", numberOfEquations, variableNameIndexMap.Count);
}
}
else
{
// An error occurred. Report the error in the status bar.
mainStatusBarText = LinearEquationParserStatusInterpreter.GetStatusString(parserStatus);
}
return(mainStatusBarText);
}
public void CalculaFluxo()
{
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
switch (Barra.Tipo[k])
{
case 0:
V_solucao[k] = 1;
break;
case 1:
V_solucao[k] = Barra.Tensao[k];
break;
case 2:
V_solucao[k] = Barra.Tensao[k];
break;
}
}
iteracaoP = 0;
iteracaoQ = 0;
KP = 1;
KQ = 1;
while (true)
{
// Meia iteração P
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
Pcal[k] = G_matriz[k, k] * Math.Pow(V_solucao[k].Magnitude, 2);
}
for (int i = 1; i <= Linha.DaBarra.Count; i++)
{
int k = Linha.DaBarra[i];
int m = Linha.ParaBarra[i];
double Vk = V_solucao[k].Magnitude;
double Vm = V_solucao[m].Magnitude;
double TetaKM = (V_solucao[k].Phase - V_solucao[m].Phase + Linha.Defasagem[i]);
double gkm = G_matriz[k, m];
double bkm = B_matriz[k, m];
Pcal[k] += Vk * Vm * (gkm * Math.Cos(TetaKM) + bkm * Math.Sin(TetaKM));
Pcal[m] += Vk * Vm * (gkm * Math.Cos(TetaKM) - bkm * Math.Sin(TetaKM));
}
for (int i = 1; i <= Barra.NBarra.Count; i++)
{
switch (Barra.Tipo[i])
{
case 2:
D_P[i] = 0;
break;
case 0:
D_P[i] = (Barra.PotenciaAtivaEsperada[i] / 100) - Pcal[i];
break;
case 1:
D_P[i] = (Barra.PotenciaAtivaEsperada[i] / 100) - Pcal[i];
break;
}
}
for (int k = 0; k < Barra.NBarra.Count; k++)
{
D_P_Solver[k] = D_P[k + 1];
}
double[] erroP = new double[Barra.NBarra.Count];
for (int k = 0; k < Barra.NBarra.Count; k++)
{
erroP[k] = D_P_Solver[k];
}
if (erroP.Max() <= 0.000001 && iteracaoP > 2)
{
KP = 0;
}
if (KP == 1)
{
// Calculando matriz H
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
double Vk = V_solucao[k].Magnitude;
switch (Barra.Tipo[k])
{
case 2:
Jacobiano_H[k, k] = 1e40;
break;
case 0:
Jacobiano_H[k, k] = -Qcal[k] - B_matriz[k, k] * Math.Pow(Vk, 2);
break;
case 1:
Jacobiano_H[k, k] = -Qcal[k] - B_matriz[k, k] * Math.Pow(Vk, 2);
break;
}
}
for (int i = 1; i <= Linha.DaBarra.Count; i++)
{
int k = Linha.DaBarra[i];
int m = Linha.ParaBarra[i];
double Vk = V_solucao[k].Magnitude;
double Vm = V_solucao[m].Magnitude;
double TetaKM = V_solucao[k].Phase - V_solucao[m].Phase;
Jacobiano_H[k, m] = Vk * Vm * (G_matriz[k, m] * Math.Sin(TetaKM) - B_matriz[k, m] * Math.Cos(TetaKM));
Jacobiano_H[m, k] = -Vk * Vm * (G_matriz[k, m] * Math.Sin(TetaKM) + B_matriz[k, m] * Math.Cos(TetaKM));
}
for (int j = 0; j < Barra.NBarra.Count; j++)
{
for (int i = 0; i < Barra.NBarra.Count; i++)
{
Jacobiano_H[j, i] = Jacobiano_H[j + 1, i + 1];
}
}
LinearEquationSolver.Solve(D_P_Solver.Count, Jacobiano_H, D_P_Solver, D_theta);
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
V_solucao[k] = Complex.FromPolarCoordinates(
V_solucao[k].Magnitude,
V_solucao[k].Phase + D_theta[k - 1]);
}
iteracaoP++;
KQ = 1;
}
else if (KQ == 0)
{
break;
}
// Meia iteração Q
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
Qcal[k] = -B_matriz[k, k] * Math.Pow(V_solucao[k].Magnitude, 2);
}
for (int i = 1; i <= Linha.DaBarra.Count; i++)
{
int k = Linha.DaBarra[i];
int m = Linha.ParaBarra[i];
double Vk = V_solucao[k].Magnitude;
double Vm = V_solucao[m].Magnitude;
double TetaKM = (V_solucao[k].Phase - V_solucao[m].Phase + Linha.Defasagem[i]);
double gkm = G_matriz[k, m];
double bkm = B_matriz[k, m];
Qcal[k] += Vk * Vm * (gkm * Math.Sin(TetaKM) - bkm * Math.Cos(TetaKM));
Qcal[m] += Vk * Vm * (-gkm * Math.Sin(TetaKM) - bkm * Math.Cos(TetaKM));
}
for (int i = 1; i <= Barra.NBarra.Count; i++)
{
switch (Barra.Tipo[i])
{
case 2:
D_Q[i] = 0;
break;
case 0:
D_Q[i] = (Barra.PotenciaReativaEsperada[i] / 100) - Qcal[i];
break;
case 1:
D_Q[i] = 0;
break;
}
}
for (int k = 0; k < Barra.NBarra.Count; k++)
{
D_Q_Solver[k] = D_Q[k + 1];
}
double[] erroQ = new double[Barra.NBarra.Count];
for (int k = 0; k < Barra.NBarra.Count; k++)
{
erroQ[k] = D_Q_Solver[k];
}
if (erroP.Max() <= 0.000001 && iteracaoP > 2)
{
KQ = 0;
}
if (KQ == 1)
{
// Calculando matriz L
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
double Vk = V_solucao[k].Magnitude;
switch (Barra.Tipo[k])
{
case 2:
Jacobiano_L[k, k] = 1e40;
break;
case 0:
Jacobiano_L[k, k] = (Qcal[k] - B_matriz[k, k] * Math.Pow(Vk, 2)) / Vk;
break;
case 1:
Jacobiano_L[k, k] = 1e40;
break;
}
}
for (int i = 1; i <= Linha.DaBarra.Count; i++)
{
int k = Linha.DaBarra[i];
int m = Linha.ParaBarra[i];
double Vk = V_solucao[k].Magnitude;
double Vm = V_solucao[m].Magnitude;
double TetaKM = V_solucao[k].Phase - V_solucao[m].Phase;
Jacobiano_L[k, m] = Vk * (G_matriz[k, m] * Math.Sin(TetaKM) - B_matriz[k, m] * Math.Cos(TetaKM));
Jacobiano_L[m, k] = -Vm * (G_matriz[k, m] * Math.Sin(TetaKM) + B_matriz[k, m] * Math.Cos(TetaKM));
}
for (int j = 0; j < Barra.NBarra.Count; j++)
{
for (int i = 0; i < Barra.NBarra.Count; i++)
{
Jacobiano_L[j, i] = Jacobiano_L[j + 1, i + 1];
}
}
for (int j = 0; j < Barra.NBarra.Count; j++)
{
D_Q_Solver[j] = D_Q[j + 1];
}
LinearEquationSolver.Solve(D_Q_Solver.Count, Jacobiano_L, D_Q_Solver, D_V);
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
V_solucao[k] = Complex.FromPolarCoordinates(
V_solucao[k].Magnitude + D_V[k - 1],
V_solucao[k].Phase);
}
iteracaoQ++;
KP = 1;
}
else if (KP == 0)
{
break;
}
}
}
private void Solve()
{
if (bSolved || iPtr == 0)
{
return;
}
daSimEqn[0, 0] = get_sum_x(12);
daSimEqn[0, 1] = get_sum_x(11);
daSimEqn[0, 2] = get_sum_x(10);
daSimEqn[0, 3] = get_sum_x(9);
daSimEqn[0, 4] = get_sum_x(8);
daSimEqn[0, 5] = get_sum_x(7);
daSimEqn[0, 6] = get_sum_x(6);
daSimEqn[0, 7] = get_sum_xy(6);
daSimEqn[1, 0] = get_sum_x(11);
daSimEqn[1, 1] = get_sum_x(10);
daSimEqn[1, 2] = get_sum_x(9);
daSimEqn[1, 3] = get_sum_x(8);
daSimEqn[1, 4] = get_sum_x(7);
daSimEqn[1, 5] = get_sum_x(6);
daSimEqn[1, 6] = get_sum_x(5);
daSimEqn[1, 7] = get_sum_xy(5);
daSimEqn[2, 0] = get_sum_x(10);
daSimEqn[2, 1] = get_sum_x(9);
daSimEqn[2, 2] = get_sum_x(8);
daSimEqn[2, 3] = get_sum_x(7);
daSimEqn[2, 4] = get_sum_x(6);
daSimEqn[2, 5] = get_sum_x(5);
daSimEqn[2, 6] = get_sum_x(4);
daSimEqn[2, 7] = get_sum_xy(4);
daSimEqn[3, 0] = get_sum_x(9);
daSimEqn[3, 1] = get_sum_x(8);
daSimEqn[3, 2] = get_sum_x(7);
daSimEqn[3, 3] = get_sum_x(6);
daSimEqn[3, 4] = get_sum_x(5);
daSimEqn[3, 5] = get_sum_x(4);
daSimEqn[3, 6] = get_sum_x(3);
daSimEqn[3, 7] = get_sum_xy(3);
daSimEqn[4, 0] = get_sum_x(8);
daSimEqn[4, 1] = get_sum_x(7);
daSimEqn[4, 2] = get_sum_x(6);
daSimEqn[4, 3] = get_sum_x(5);
daSimEqn[4, 4] = get_sum_x(4);
daSimEqn[4, 5] = get_sum_x(3);
daSimEqn[4, 6] = get_sum_x(2);
daSimEqn[4, 7] = get_sum_xy(2);
daSimEqn[5, 0] = get_sum_x(7);
daSimEqn[5, 1] = get_sum_x(6);
daSimEqn[5, 2] = get_sum_x(5);
daSimEqn[5, 3] = get_sum_x(4);
daSimEqn[5, 4] = get_sum_x(3);
daSimEqn[5, 5] = get_sum_x(2);
daSimEqn[5, 6] = get_sum_x(1);
daSimEqn[5, 7] = get_sum_xy(1);
daSimEqn[6, 0] = get_sum_x(6);
daSimEqn[6, 1] = get_sum_x(5);
daSimEqn[6, 2] = get_sum_x(4);
daSimEqn[6, 3] = get_sum_x(3);
daSimEqn[6, 4] = get_sum_x(2);
daSimEqn[6, 5] = get_sum_x(1);
daSimEqn[6, 6] = 1;
daSimEqn[6, 7] = get_sum_xy(0);
if (LinearEquationSolver.Solve(daSimEqn))
{
daTerm = daSimEqn[0, 7];
dbTerm = daSimEqn[1, 7];
dcTerm = daSimEqn[2, 7];
ddTerm = daSimEqn[3, 7];
deTerm = daSimEqn[4, 7];
dfTerm = daSimEqn[5, 7];
dgTerm = daSimEqn[6, 7];
}
}
public ActionResult GetResult(string equations)
{
var equationsList = new JavaScriptSerializer().Deserialize <IEnumerable <string> >(equations).ToList();
RemoveWhiteSpaces(equationsList);
ChangeCommasToPoints(equationsList);
if (!equationsList.SystemIsCorrect())
{
return(Json(new { result = false, reason = new Reason {
isMathematical = false, reasonText = "It's not a system"
} }));
}
float[,] matrix;
bool isSolved = false;
try
{
matrix = equationsList.GetMatrix();
}
catch (Exception e)
{
if (e is LinearSystemException)
{
return
(Json(new { result = false, reason = new Reason {
isMathematical = true, reasonText = e.Message
} }));
}
return(Json(new { result = false, reason = new Reason {
isMathematical = false, reasonText = e.Message
} }));
}
try
{
isSolved = LinearEquationSolver.Solve(matrix);
}
catch (Exception e)
{
if (e is LinearSystemException)
{
return
(Json(new { result = false, reason = new Reason {
isMathematical = true, reasonText = e.Message
} }));
}
return(Json(new { result = false, reason = new Reason {
isMathematical = false, reasonText = e.Message
} }));
}
if (isSolved)
{
var variables = Parser.GetAllVariables(equationsList);
string resultString = string.Empty;
for (int i = 0; i < variables.Count; i++)
{
resultString += string.Format("{0} = {1}\n", variables.ElementAt(i), matrix[i, variables.Count]);
}
return(Json(new { result = true, solution = resultString }));
}
return(Json(new { result = false, reason = new Reason {
isMathematical = true, reasonText = "System is incompatible"
} }));
}
public void CalculaFluxo()
{
while (CalculaCondicao() || iteracao < 5)
{
// Definindo valores iniciais
if (iteracao == 0)
{
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
switch (Barra.Tipo[k])
{
case 0:
V_solucao[iteracao, k] = 1;
break;
case 1:
V_solucao[iteracao, k] = Barra.Tensao[k];
break;
case 2:
V_solucao[iteracao, k] = Barra.Tensao[k];
break;
}
}
iteracao++;
continue;
}
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
Pcal[k] = G_matriz[k, k] * Math.Pow(V_solucao[iteracao - 1, k].Magnitude, 2);
Qcal[k] = -B_matriz[k, k] * Math.Pow(V_solucao[iteracao - 1, k].Magnitude, 2);
}
for (int i = 1; i <= Linha.DaBarra.Count; i++)
{
int k = Linha.DaBarra[i];
int m = Linha.ParaBarra[i];
double Vk = V_solucao[iteracao - 1, k].Magnitude;
double Vm = V_solucao[iteracao - 1, m].Magnitude;
double TetaKM = (V_solucao[iteracao - 1, k].Phase - V_solucao[iteracao - 1, m].Phase + Linha.Defasagem[i]);
double gkm = G_matriz[k, m];
double bkm = B_matriz[k, m];
Pcal[k] += Vk * Vm * (gkm * Math.Cos(TetaKM) + bkm * Math.Sin(TetaKM));
Pcal[m] += Vk * Vm * (gkm * Math.Cos(TetaKM) - bkm * Math.Sin(TetaKM));
Qcal[k] += Vk * Vm * (gkm * Math.Sin(TetaKM) - bkm * Math.Cos(TetaKM));
Qcal[m] += Vk * Vm * (-gkm * Math.Sin(TetaKM) - bkm * Math.Cos(TetaKM));
}
// Calculando as submatrizes da matriz Jacobiano (H, N, M e L)
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
double Vk = V_solucao[iteracao - 1, k].Magnitude;
switch (Barra.Tipo[k])
{
case 2:
Jacobiano_H[k, k] = 1e40;
Jacobiano_N[k, k] = (Pcal[k] + G_matriz[k, k] * Math.Pow(Vk, 2)) / Vk;
Jacobiano_M[k, k] = Pcal[k] - G_matriz[k, k] * Math.Pow(Vk, 2);
Jacobiano_L[k, k] = 1e40;
break;
case 0:
Jacobiano_H[k, k] = -Qcal[k] - B_matriz[k, k] * Math.Pow(Vk, 2);
Jacobiano_N[k, k] = (Pcal[k] + G_matriz[k, k] * Math.Pow(Vk, 2)) / Vk;
Jacobiano_M[k, k] = Pcal[k] - G_matriz[k, k] * Math.Pow(Vk, 2);
Jacobiano_L[k, k] = (Qcal[k] - B_matriz[k, k] * Math.Pow(Vk, 2)) / Vk;
break;
case 1:
Jacobiano_H[k, k] = -Qcal[k] - B_matriz[k, k] * Math.Pow(Vk, 2);
Jacobiano_N[k, k] = (Pcal[k] + G_matriz[k, k] * Math.Pow(Vk, 2)) / Vk;
Jacobiano_M[k, k] = Pcal[k] - G_matriz[k, k] * Math.Pow(Vk, 2);
Jacobiano_L[k, k] = 1e40;
break;
}
}
for (int i = 1; i <= Linha.DaBarra.Count; i++)
{
int k = Linha.DaBarra[i];
int m = Linha.ParaBarra[i];
double Vk = V_solucao[iteracao - 1, k].Magnitude;
double Vm = V_solucao[iteracao - 1, m].Magnitude;
double TetaKM = V_solucao[iteracao - 1, k].Phase - V_solucao[iteracao - 1, m].Phase;
Jacobiano_H[k, m] = Vk * Vm * (G_matriz[k, m] * Math.Sin(TetaKM) - B_matriz[k, m] * Math.Cos(TetaKM));
Jacobiano_H[m, k] = -Vk * Vm * (G_matriz[k, m] * Math.Sin(TetaKM) + B_matriz[k, m] * Math.Cos(TetaKM));
Jacobiano_N[k, m] = Vk * (G_matriz[k, m] * Math.Cos(TetaKM) + B_matriz[k, m] * Math.Sin(TetaKM));
Jacobiano_N[m, k] = Vm * (G_matriz[k, m] * Math.Cos(TetaKM) - B_matriz[k, m] * Math.Sin(TetaKM));
Jacobiano_M[k, m] = -Vk * Vm * (G_matriz[k, m] * Math.Cos(TetaKM) + B_matriz[k, m] * Math.Sin(TetaKM));
Jacobiano_M[m, k] = -Vk * Vm * (G_matriz[k, m] * Math.Cos(TetaKM) - B_matriz[k, m] * Math.Sin(TetaKM));
Jacobiano_L[k, m] = Vk * (G_matriz[k, m] * Math.Sin(TetaKM) - B_matriz[k, m] * Math.Cos(TetaKM));
Jacobiano_L[m, k] = -Vm * (G_matriz[k, m] * Math.Sin(TetaKM) + B_matriz[k, m] * Math.Cos(TetaKM));
}
// Montando a matriz Jacobiano
for (int j = 0; j < Barra.NBarra.Count; j++)
{
for (int i = 0; i < Barra.NBarra.Count; i++)
{
int n = Barra.NBarra.Count;
Jacobiano[j, i] = Jacobiano_H[j + 1, i + 1];
Jacobiano[j + n, i] = Jacobiano_M[j + 1, i + 1];
Jacobiano[j, i + n] = Jacobiano_N[j + 1, i + 1];
Jacobiano[j + n, i + n] = Jacobiano_L[j + 1, i + 1];
}
}
// Calculando os erros DPQ
for (int i = 1; i <= Barra.NBarra.Count; i++)
{
int n = Barra.NBarra.Count;
switch (Barra.Tipo[i])
{
case 2:
D_PQ[i] = 0;
D_PQ[i + n] = 0;
break;
case 0:
D_PQ[i] = (Barra.PotenciaAtivaEsperada[i] / 100) - Pcal[i];
D_PQ[i + n] = (Barra.PotenciaReativaEsperada[i] / 100) - Qcal[i];
break;
case 1:
D_PQ[i] = (Barra.PotenciaAtivaEsperada[i] / 100) - Pcal[i];
D_PQ[i + n] = 0;
break;
}
}
for (int j = 0; j < 2 * Barra.NBarra.Count; j++)
{
D_PQ_Solver[j] = D_PQ[j + 1];
}
LinearEquationSolver.Solve(D_PQ_Solver.Count, Jacobiano, D_PQ_Solver, D_theta_V);
for (int i = 1; i <= Barra.NBarra.Count; i++)
{
D_theta[i] = D_theta_V[i - 1];
D_V[i] = D_theta_V[i + Barra.NBarra.Count - 1];
}
// Atualizando os valores
for (int k = 1; k <= Barra.NBarra.Count; k++)
{
V_solucao[iteracao, k] = Complex.FromPolarCoordinates(
V_solucao[iteracao - 1, k].Magnitude + D_V[k],
V_solucao[iteracao - 1, k].Phase + D_theta[k]);
}
iteracao++;
}
}