Önce kendiniz 2. ve 3. dereceden 2 bilinmeyenli denklemi hangi formüle göre yaptıysanız bir örnek yapın. Sonra bu örnekte bulunan matematiksel işlemi koda aktarın.
Yani diskriminatı bulup denklemde yerine koyarak basitçe üç satırda bulursun. Kök almak için yada kuvvetini almak için google python sqrt veya üs için pow araması yapmak yeterli.
Tabi ki bu ikinci derece bir bilinmeyenli denklem için.
Yani öneriye yanlış diyemeyiz. Normal şartlarda yapmanız gereken bu aslında. Matematiksel denklemin çözüm formülasyonunu bulup onu yukarıdaki gibi koda çevirmek. Çarp böl topla.
Benim önerdiğim ise asıl hazır kütüphane.
solve( Denklem, x, y, dict= True veya set= True)
Örnek de sitede var zaten:
solve([x**2 - 3, y - 1], set=True )
Yani daha basit nasıl olabilir bilemedim.
x3-y2-10 yaz bak mesela yanda denemek için seçenek de var.
Bilgisayar bilimlerinde denklem çözümleri Sayısal Yöntemler dersinde anlatılmaktadır. Hangi konularda araştırma yapmanız gerektiği konusunda yardımcı olması için küçük bir kesit paylaşıyorum.
Daha önce sevgili @coderistan , Sayısal Yöntemler dersinde anlatılan yöntemlerle ilgili bir görsel paylaşmıştı.
Görselde yer alan yöntemlerden ilki olan Newton-Raphson yöntemi ile ilgili bir örnek yapalım isterim.
Bu yöntem, lineer olmayan bir f(x) fonksiyonunun 0’a eşit olduğu yere, Taylor Serilerini kullanarak yakınsamaya çalışan bir yöntemdir.
Yöntem şöyle çalışıyor:
f(x)'in 0’a yaklaşabilmesi için bir başlangıç değeri seçiyoruz. Başlangıç değeri complex tipte bir sayı. Neden complex? Çünkü, denklemin reel kökleri olmayabilir.
Burada, her başlangıç değeri, f(x) = 0’a yaklaşmayı sağlamayabilir. Başlangıç değerlerini öyle bir şekilde seçmemiz lazım ki, fonksiyonun kökleri daha isabetli bir şekilde hesaplanabilsin.
Kompleks sayılar için en uygun başlangıç değerleri, bu sayılar bir çemberin kökleriyle ilgili oldukları için; çember üzerinde eşit bir şekilde dağılmış noktalar olarak seçilir. Bu seçimde, elbette cos ve sin fonksiyonlarını kullanmamız gerekiyor.
Kök sayısı, denklemin derece sayısına bağlı bir kavramdır. 3. dereceden denklemin toplamda 3 kökü, 4 katsayısı vardır.
Yani eğer denklemde 3 kök varsa, bu kökleri bulmak için başlangıç değerleri şöyle oluşturulabilir:
from math import pi, cos, sin
n = 3
roots = [complex(cos(2 * pi * i / n), sin(2 * pi * i / n) for i in range(n)]
print(roots)
Newton-Rhapson yöntemi, f(x) fonksiyonunun mevcut eğimi boyunca sürekli türevinin alınarak, türevin 0’a yaklaştığı yeri bulmaya çalışır.
x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}
Türev fonksiyonunu şöyle yazabiliriz:
def derivate(
x: complex,
n: int,
coef: list[float],
h: float = 1e-5
) -> complex:
return (func(x + h, n, coef) - func(x, n, coef)) / h
Newton-Rhapson yöntemi ise şöyle yazılabilir:
def newton_rhapson_method(
n: int,
coef: list[float],
roots: list[complex],
max_step: int,
tolerance: float
) -> None:
for i in range(n):
x = complex(cos(2 * pi * i / n), sin(2 * pi * i / n))
for step in range(max_step):
x = x - func(x, n, coef) / derivate(x, n, coef)
if abs(func(x, n, coef)) < tolerance:
break
roots[i] = x
Bu fonksiyonları oluşturduktan sonra, katsayılara göre değişecek olan denklem fonksiyonunu tanımlayalım:
def func(x: complex, n: int, coef: list[float]) -> complex:
total = complex(0, 0)
for i in range(n + 1):
total += coef[i] * x ** (n - i)
return total
Buradaki func fonksiyonu, köklerini bulmaya çalıştığımız fonksiyonu üretir ve bu fonksiyonu karmaşık tipte olan x değerleri ile çalıştırır.
Şimdi, main fonksiyonunu tanımlayabiliriz:
def main():
coef = [1, -1, -1]
n = len(coef) - 1
roots = [complex(0, 0)] * n
newton_rhapson_method(n, coef, roots, 100, 1e-7)
for i in range(n):
print(f"{roots[i].real} + {roots[i].imag}j")
if __name__ == "__main__":
main()
Yukarıda coef isimli değişken, 2. dereceden bir denklem olan Fibonacci Serisi fonksiyonunun katsayıları olan 1, -1, -1 değelerini içeren katsayı listesidir.
Fibonacci fonksiyonunun denklemi::
f(x) = x^2 -x - 1
Gördüğünüz gibi, bu denklemin katsayıları [1, -1, -1].
Fibonacci fonksiyonu ile alakalı olarak aşağıdaki başlığı da incelemenizi tavsiye ederim:
Yukarıdaki başlıkta fibonacci fonksiyonunun kökleri şöyle bulunmuştu:
Ondalık kısımda farklılıklar olması beklenen bir durumdur.
Newton-Raphson yöntemi, bir fonksiyonun kökünü bulmak için, başlangıç değeri kullanır ve yinelemeli (iteratif) bir yaklaşım yapılır. Bu yaklaşım, her adımda fonksiyonun türevini kullanarak köke daha yakın bir noktaya yaklaşılmasını sağlar.
Diğer yandan, Durand-Kerner yönteminde, başlangıç değerleri seçilmez; polinomun katsayıları kullanılarak bir companion matrix (kompanyon/refakatçı matris) oluşturulur. Bu matrisin özdeğerleri hesaplanarak, polinomun kökleri bulunur. Özdeğerler, matrisin karakteristik özelliklerini gösteren ve polinomun köklerine karşılık gelen değerlerdir. Bu yaklaşımda, kökler doğrudan kompanyon matrisin özdeğerlerinden elde edilir.
Durand-Kerner yöntemi, Newton-Raphson yöntemine kıyasla, özellikle polinomların köklerini aynı anda ve daha isabetli bir şekilde bulması açısından avantajlıdır.
Durand-Kerner yöntemi ile alakalı olarak aşağıdaki linkleri de inceleyebilirsiniz:
Durand-Kerner Yöntemi:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def dot_product(n: int, v1: list[complex], v2: list[complex]) -> complex:
result = complex(0, 0)
for i in range(n):
result += v1[i] * v2[i]
return result
def scalar_multiply(
n: int,
scalar: complex,
vector: list[complex],
multiplied: list[complex]
) -> None:
for i in range(n):
multiplied[i] = scalar * vector[i]
def vector_subtract(
n: int,
v1: list[complex],
v2: list[complex],
subtracted: list[complex]
) -> None:
for i in range(n):
subtracted[i] = v1[i] - v2[i]
def gram_schmidt(
n: int,
A: list[list[complex]],
Q: list[list[complex]],
R: list[list[complex]],
) -> None:
for i in range(n):
v = [complex(0, 0)] * n
for j in range(n):
v[j] = A[j][i]
for j in range(i):
R[j][i] = dot_product(n, Q[j], v)
multiplied = [complex(0, 0)] * n
scalar_multiply(n, R[j][i], Q[j], multiplied)
subtracted = [complex(0, 0)] * n
vector_subtract(n, v, multiplied, subtracted)
for k in range(n):
v[k] = subtracted[k]
R[i][i] = dot_product(n, v, v) ** .5
for j in range(n):
Q[i][j] = v[j] / R[i][i]
def qr_algorithm(
n: int,
roots: list[complex],
companion: list[list[float]],
A: list[list[complex]],
Q: list[list[complex]],
R: list[list[complex]],
max_step: int,
tolerance: float
) -> None:
for i in range(n):
for j in range(n):
A[i][j] = complex(0, companion[i][j])
for step in range(max_step):
for i in range(n):
for j in range(n):
Q[i][j] = complex(0, 0)
R[i][j] = complex(0, 0)
gram_schmidt(n, A, Q, R)
for i in range(n):
for j in range(n):
total = complex(0, 0)
for k in range(n):
total += R[i][k] * Q[k][j]
A[i][j] = total
converged = 1
for i in range(1, n):
for j in range(i):
if abs(A[i][j]) >= tolerance:
converged = 0
break
if not converged:
break
if converged:
break
for i in range(n):
roots[i] = A[i][i]
def companion_matrix(
n: int,
coef: list[float],
companion: list[list[float]]
) -> None:
for i in range(n):
for j in range(n):
if not j:
companion[i][j] = -1.0 * coef[i + 1] / coef[0]
elif i + 1 == j:
companion[i][j] = 1
def func(x: complex, n: int, coef: list[float]) -> complex:
total = complex(0, 0)
for i in range(n + 1):
total += coef[i] * x ** (n - i)
return total
def durand_kerner_method(
n: int,
coef: list[float],
roots: list[complex],
max_step: int,
tolerance: float
):
companion = [[0] * n for _ in range(n)]
companion_matrix(n, coef, companion)
A = [[complex(0, 0)] * n for _ in range(n)]
Q = [[complex(0, 0)] * n for _ in range(n)]
R = [[complex(0, 0)] * n for _ in range(n)]
qr_algorithm(n, roots, companion, A, Q, R, max_step, tolerance)
for i in range(n):
for step in range(max_step):
denominator = complex(1, 0)
for j in range(n):
if i != j:
denominator *= roots[i] - roots[j]
roots[i] = roots[i] - func(roots[i], n, coef) / denominator
if abs(func(roots[i], n, coef)) < tolerance:
break
def main():
coef = [1, -1, -1]
n = len(coef) - 1
roots = [complex(0, 0)] * n
durand_kerner_method(n, coef, roots, 100, 1e-7)
for i in range(n):
print(f"{roots[i].real} + {roots[i].imag}j")
if __name__ == "__main__":
main()
Bu arada, konuyla alakalı değil ama, yakın zamanda keşfettiğim bir durumdan da bahsetmek isterim.
Python’daki complex tipi ile yaptığımız işlemleri, C ve C++ dillerindeki complex tipleri ile yapmaya çalıştığımızda, Python’daki sonuçlarla aynı sonuçları alamayabiliriz.
Python’daki complex sınıfı ile yapılabilen işlemlerin benzerlerini, C’de ve C++'da kullanabilmek için, Python’daki complex tipine benzer, yeni bir complex tipi ve o tipe uygun fonksiyonları baştan yazmak zorunda kaldım.
C
#include <math.h>
#include <stdio.h>
typedef struct Complex {
long double re;
long double im;
} Complex;
Complex sum_complex(const Complex c1, const Complex c2) {
return (Complex){c1.re + c2.re, c1.im + c2.im};
}
Complex sub_complex(const Complex c1, const Complex c2) {
return (Complex){c1.re - c2.re, c1.im - c2.im};
}
Complex mul_complex(const Complex c1, const Complex c2) {
long double re = c1.re * c2.re - c1.im * c2.im;
long double im = c1.re * c2.im + c2.re * c1.im;
return (Complex){re, im};
}
Complex div_complex(const Complex c1, const Complex c2) {
long double denominator = c2.re * c2.re + c2.im * c2.im;
long double re = (c1.re * c2.re + c1.im * c2.im) / denominator;
long double im = (c1.im * c2.re - c1.re * c2.im) / denominator;
return (Complex){re, im};
}
Complex sqrt_complex(const Complex c) {
long double modulus = sqrt(sqrt(c.re * c.re + c.im * c.im));
long double q = atan2(c.im, c.re);
long double re = modulus * cos(q / 2.0);
long double im = modulus * sin(q / 2.0);
return (Complex){re, im};
}
Complex scalar_sum_complex(const Complex c, const long double n) {
return (Complex){c.re + n, c.im};
}
Complex scalar_mul_complex(const Complex c, const long double n) {
return (Complex){c.re * n, c.im * n};
}
Complex scalar_div_complex(const Complex c, const long double n) {
return (Complex){c.re / n, c.im / n};
}
long double abs_complex(const Complex c) {
return sqrt(c.re * c.re + c.im * c.im);
}
Complex pow_complex(const Complex c, const int n) {
int i = 0;
Complex result = {1.0, 0.0};
while (i != n) {
result = mul_complex(result, c);
i++;
}
return result;
}
Complex dot_product(
const int n,
const Complex v1[n],
const Complex v2[n]
) {
Complex result = {0.0, 0.0};
for (int i = 0; i < n; i++) {
result = sum_complex(result, mul_complex(v1[i], v2[i]));
}
return result;
}
void scalar_multiply(
const int n,
const Complex scalar,
const Complex vector[n],
Complex multiplied[n]
) {
for (int i = 0; i < n; i++) {
multiplied[i] = mul_complex(scalar, vector[i]);
}
}
void vector_subtract(
const int n,
const Complex v1[n],
const Complex v2[n],
Complex subtracted[n]
) {
for (int i = 0; i < n; i++) {
subtracted[i] = sub_complex(v1[i], v2[i]);
}
}
void gram_schmidt(
const int n,
Complex A[n][n],
Complex Q[n][n],
Complex R[n][n]
) {
for (int i = 0; i < n; i++) {
Complex v[n];
for (int j = 0; j < n; j++) { v[j] = A[j][i]; }
for (int j = 0; j < i; j++) {
R[j][i] = dot_product(n, Q[j], v);
Complex multiplied[n];
scalar_multiply(n, R[j][i], Q[j], multiplied);
Complex subtracted[n];
vector_subtract(n, v, multiplied, subtracted);
for (int k = 0; k < n; k++) { v[k] = subtracted[k]; }
}
R[i][i] = sqrt_complex(dot_product(n, v, v));
for (int j = 0; j < n; j++) { Q[i][j] = div_complex(v[j], R[i][i]); }
}
}
void qr_algorithm(
const int n,
Complex roots[n],
long double companion[n][n],
Complex A[n][n],
Complex Q[n][n],
Complex R[n][n],
const int max_step,
const long double tolerance
) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
A[i][j] = (Complex){0.0, companion[i][j]};
}
}
for (int step = 0; step < max_step; step++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Q[i][j] = (Complex){0.0, 0.0};
R[i][j] = (Complex){0.0, 0.0};
}
}
gram_schmidt(n, A, Q, R);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Complex total = {0.0, 0.0};
for (int k = 0; k < n; k++) {
total = sum_complex(total, mul_complex(R[i][k], Q[k][j]));
}
A[i][j] = total;
}
}
int converged = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (abs_complex(A[i][j]) >= tolerance) {
converged = 0;
break;
}
}
if (!converged) { break; }
}
if (converged) { break; }
}
for (int i = 0; i < n; i++) { roots[i] = A[i][i]; }
}
void companion_matrix(
const int n,
const long double coef[n + 1],
long double companion[n][n]
) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!j) { companion[i][j] = -1.0 * coef[i + 1] / coef[0]; }
else if (i + 1 == j) { companion[i][j] = 1; }
else { companion[i][j] = 0; }
}
}
}
Complex func(const Complex x, const int n, const long double coef[n]) {
Complex total = {0.0, 0.0};
for (int i = 0; i < n + 1; i++) {
total = sum_complex(
total,
scalar_mul_complex(pow_complex(x, n - i), coef[i])
);
}
return total;
}
void durand_kerner_method(
const int n,
const long double coef[n + 1],
Complex roots[n],
const int max_step,
const long double tolerance
) {
long double companion[n][n];
companion_matrix(n, coef, companion);
Complex A[n][n];
Complex Q[n][n];
Complex R[n][n];
qr_algorithm(n, roots, companion, A, Q, R, max_step, tolerance);
for (int i = 0; i < n; i++) {
for (int step = 0; step < max_step; step++) {
Complex denominator = {1.0, 0.0};
for (int j = 0; j < n; j++) {
if (i != j) {
denominator = mul_complex(
denominator,
sub_complex(roots[i], roots[j])
);
}
}
roots[i] = sub_complex(
roots[i],
div_complex(func(roots[i], n, coef), denominator)
);
if (abs_complex(func(roots[i], n, coef)) < tolerance) {
break;
}
}
}
}
Complex derivate(
const Complex x,
const int n,
const long double coef[n],
const long double h
) {
return scalar_div_complex(
sub_complex(func(scalar_sum_complex(x, h), n, coef), func(x, n, coef)),
h
);
}
void newton_rhapson_method(
const int n,
const long double coef[n],
Complex roots[n - 1],
const int max_step,
const long double tolerance
) {
for (int i = 0; i < n; i++) {
Complex x = {cos(2 * M_PI * i / n), sin(2 * M_PI * i / n)};
for (int step = 0; step < max_step; step++) {
x = sub_complex(
x,
div_complex(func(x, n, coef), derivate(x, n, coef, 1e-5))
);
if (abs_complex(func(x, n, coef)) < tolerance) { break; }
}
roots[i] = x;
}
}
int main() {
long double coef[] = {1, -1, -1};
int n = sizeof(coef) / sizeof(coef[0]) - 1;
Complex roots1[n];
Complex roots2[n];
durand_kerner_method(n, coef, roots1, 100, 1e-7);
newton_rhapson_method(n, coef, roots2, 100, 1e-7);
for (int i = 0; i < n; i++) {
printf("%Le + %Lej\n", roots1[i].re, roots1[i].im);
printf("%Le + %Lej\n", roots2[i].re, roots2[i].im);
}
return 0;
}
C++
#include <cmath>
#include <vector>
#include <iostream>
template <typename T>
using vector = std::vector<T>;
class Complex {
public:
Complex(long double re, long double im) : re(re), im(im) {};
~Complex() = default;
long double re;
long double im;
Complex operator+(const Complex& c) const {
return {re + c.re, im + c.im};
}
Complex operator-(const Complex& c) const {
return {re - c.re, im - c.im};
}
Complex operator*(const Complex& c) const {
return {re * c.re - im * c.im, re * c.im + c.re * im};
}
Complex operator/(const Complex& c) const {
long double denominator = c.re * c.re + c.im * c.im;
long double r = (re * c.re + im * c.im) / denominator;
long double i = (im * c.re - re * c.im) / denominator;
return {r, i};
}
Complex operator+(const long double n) const {
return {re + n, im};
}
Complex operator*(const long double n) const {
return {re * n, im * n};
}
Complex operator/(const long double n) const {
return {re / n, im / n};
}
Complex sqrt() {
long double modulus = std::sqrt(std::sqrt(re * re + im * im));
long double q = atan2(im, re);
long double r = modulus * cos(q / 2.0);
long double i = modulus * sin(q / 2.0);
return {r, i};
}
long double abs() {
return std::sqrt(re * re + im * im);
}
Complex pow(const int n) {
Complex result(1.0, 0.0);
Complex base = *this;
for (int i = 0; i < n; i++)
result = result * base;
return result;
}
};
Complex dot_product(
const int n,
const vector<Complex>& v1,
const vector<Complex>& v2
) {
Complex result(0.0, 0.0);
for (int i = 0; i < n; i++) {
result = result + v1[i] * v2[i];
}
return result;
}
void scalar_multiply(
const int n,
const Complex scalar,
const vector<Complex>& vec,
vector<Complex>& multiplied
) {
for (int i = 0; i < n; i++) {
multiplied[i] = vec[i] * scalar;
}
}
void vector_subtract(
const int n,
const vector<Complex>& v1,
const vector<Complex>& v2,
vector<Complex>& subtracted
) {
for (int i = 0; i < n; i++) {
subtracted[i] = v1[i] - v2[i];
}
}
void gram_schmidt(
const int n,
vector<vector<Complex>>& A,
vector<vector<Complex>>& Q,
vector<vector<Complex>>& R
) {
for (int i = 0; i < n; i++) {
vector<Complex> v(n, {0.0, 0.0});
for (int j = 0; j < n; j++) { v[j] = A[j][i]; }
for (int j = 0; j < i; j++) {
R[j][i] = dot_product(n, Q[j], v);
vector<Complex> multiplied(n, {0.0, 0.0});
scalar_multiply(n, R[j][i], Q[j], multiplied);
vector<Complex> subtracted(n, {0.0, 0.0});
vector_subtract(n, v, multiplied, subtracted);
for (int k = 0; k < n; k++) { v[k] = subtracted[k]; }
}
R[i][i] = dot_product(n, v, v).sqrt();
for (int j = 0; j < n; j++) { Q[i][j] = v[j] / R[i][i]; }
}
}
void qr_algorithm(
const int n,
vector<Complex>& roots,
vector<vector<long double>>& companion,
vector<vector<Complex>>& A,
vector<vector<Complex>>& Q,
vector<vector<Complex>>& R,
const int max_step,
const long double tolerance
) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
A[i][j] = {0.0, companion[i][j]};
}
}
for (int step = 0; step < max_step; step++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Q[i][j] = {0.0, 0.0};
R[i][j] = {0.0, 0.0};
}
}
gram_schmidt(n, A, Q, R);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Complex total(0.0, 0.0);
for (int k = 0; k < n; k++) {
total = total + R[i][k] * Q[k][j];
}
A[i][j] = total;
}
}
int converged = 1;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (A[i][j].abs() >= tolerance) {
converged = 0;
break;
}
}
if (!converged) { break; }
}
if (converged) { break; }
}
for (int i = 0; i < n; i++) { roots[i] = A[i][i]; }
}
void companion_matrix(
const int n,
const vector<long double>& coef,
vector<vector<long double>>& companion
) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!j) { companion[i][j] = -1.0 * coef[i + 1] / coef[0]; }
else if (i + 1 == j) { companion[i][j] = 1; }
}
}
}
Complex func(
Complex x,
const int n,
const vector<long double>& coef
) {
Complex total(0.0, 0.0);
for (int i = 0; i < n + 1; i++) {
total = total + x.pow(n - i) * coef[i];
}
return total;
}
void durand_kerner_method(
const int n,
const vector<long double>& coef,
vector<Complex>& roots,
const int max_step,
const long double tolerance
) {
vector<vector<long double>> companion(n, vector<long double>(n, 0.0));
companion_matrix(n, coef, companion);
vector<vector<Complex>> A(n, vector<Complex>(n, {0.0, 0.0}));
vector<vector<Complex>> Q(n, vector<Complex>(n, {0.0, 0.0}));
vector<vector<Complex>> R(n, vector<Complex>(n, {0.0, 0.0}));
qr_algorithm(n, roots, companion, A, Q, R, max_step, tolerance);
for (int i = 0; i < n; i++) {
for (int step = 0; step < max_step; step++) {
Complex denominator(1.0, 0.0);
for (int j = 0; j < n; j++) {
if (i != j) {
denominator = denominator * (roots[i] - roots[j]);
}
}
roots[i] = roots[i] - func(roots[i], n, coef) / denominator;
if (func(roots[i], n, coef).abs() < tolerance) {
break;
}
}
}
}
Complex derivate(
const Complex x,
const int n,
const vector<long double>& coef,
const long double h
) {
return (func(x + h, n, coef) - func(x, n, coef)) / h;
}
void newton_rhapson_method(
const int n,
const vector<long double>& coef,
vector<Complex>& roots,
const int max_step,
const long double tolerance
) {
for (int i = 0; i < n; i++) {
Complex x = {cos(2 * M_PI * i / n), sin(2 * M_PI * i / n)};
for (int step = 0; step < max_step; step++) {
x = x - func(x, n, coef) / derivate(x, n, coef, 1e-5);
if (func(x, n, coef).abs() < tolerance) { break; }
}
roots[i] = x;
}
}
int main() {
vector<long double> coef = {1, -1, -1};
int n = coef.size() - 1;
vector<Complex> roots1(n, {0.0, 0.0});
vector<Complex> roots2(n, {0.0, 0.0});
durand_kerner_method(n, coef, roots1, 100, 1e-7);
newton_rhapson_method(n, coef, roots2, 100, 1e-7);
for (int i = 0; i < n; i++) {
std::cout << std::scientific << roots1[i].re << " + " <<
std::scientific << roots1[i].im << "j" << std::endl;
std::cout << std::scientific << roots2[i].re << " + " <<
std::scientific << roots2[i].im << "j" << std::endl;
}
return 0;
}
vay be 3 yıl oldu demek. çoğunu unuttum bile. örnekler ile ilgili araştırma yapıp, artı ve eksileriyle katkıda bulunmak isterdim ama sen zaten her şeyiyle en güzel konulara değinmişsin. eline sağlık @dildeolupbiten
Bahsi açılmışken, ekran görüntüsünü paylaştığım kitabı tekrar araştırdım ve sayın Doç. Dr. Turhan ÇOBAN hocamızın kendi sitesinde güncellenmiş halini paylaştığını gördüm. Kendisine ne kadar teşekkür etsek azdır, böyle kaliteli ve detaylı bir kaynağı yazıp ücretsiz paylaşmak anlatılamaz bir olay. Örnekler Java ile yazılmıştır.