# Kodlamasorusu1 **URL:** \ **Category:** Makine Mühendisliği\ **Tags:** ödev\ **Created:** [Mart 28, 2025, 7:34öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962 "2025-03-28T07:34:23Z")\ **Posts on this page:** 6\ **Page:** 1
**Author:** ![Muhammed\_Burak\_TÜRKY](https://sorumatik.co/user_avatar/sorumatik.co/muhammed_burak_t%C3%BCrky/32/10409_2.png) [@Muhammed\_Burak\_TÜRKY](https://sorumatik.co/u/Muhammed_Burak_T%C3%9CRKY)\ **Post date:** [Mart 28, 2025, 7:34öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962/1 "2025-03-28T07:34:23Z")
![Ekran görüntüsü 2025-03-28 103401](https://sorumatik.co/uploads/default/original/3X/2/9/29babb9fc70382d27ec2cc6433fabd5535428990.png) ---
**Author:** ![Ders\_Asistani](https://sorumatik.co/user_avatar/sorumatik.co/ders_asistani/32/109340_2.png) [@Ders\_Asistani](https://sorumatik.co/u/Ders_Asistani)\ **Post date:** [Mart 28, 2025, 7:34öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962/2 "2025-03-28T07:34:38Z")
**Soru Açıklaması:** Soru, \exp(x) fonksiyonunun Maclaurin serisi kullanılarak yaklaşık olarak hesaplanması ile ilgilidir. MATLAB’de verilen algoritmayı .m dosyasına kodlayarak çalıştırmanız ve hata (tolerans) değerini değiştirerek iterasyon sayısının nasıl etkilendiğini gözlemlemeniz isteniyor. * * * ### **MATLAB Kod Açıklaması:** Verilen algoritma, \exp(x) değerini aşağıdaki Maclaurin serisi ile yaklaşık olarak hesaplar: \exp(x) = 1 + \frac{x}{1!} + \frac{x^2}{2!} + \frac{x^3}{3!} + \dots Bu algoritma: 1. x’e göre \exp(x)'in bir yakınsamasını hesaplar. 2. Belirtilen hata kriterine (es) ulaşana kadar seri terimlerini toplar. 3. İterasyon sayısını ve yakınsak değeri döndürür. * * * ### **Verilen Kodun MATLAB Versiyonu:** Aşağıdaki kod, verilen algoritmayı MATLAB’de çalıştırabilir şekilde düzenlenmiştir: ```matlab clc; clear; % Başlangıç değerlerini tanımlıyoruz a1 = 0; % Sum'ın güncel değeri a0 = 0; % Önceki iterasyondaki toplam Terim = 0; % Serinin bir sonraki eklenecek terimi x = -0.5; % Hesaplamak istediğimiz x değeri n = 0; % İterasyon adımı (başlangıç sıfır) es = 5e-4; % Belirlenen hata toleransı ea = 5e-3; % İlk başta başlangıç hatası while ea > es % Seri genişlemesi için terim hesaplama Terim = (x^n) / factorial(n); a0 = a1; % Önceki toplamı kaydet a1 = a1 + Terim; % Yeni toplamı hesapla ea = 100 * abs((a1 - a0) / a1); % Hataları yüzde olarak hesapla n = n + 1; % İterasyon sayısını artır end % Sonuçları yazdırma disp(['Son iterasyon sayısı: ', num2str(n)]); disp(['e^x yaklaşık sonucu: ', num2str(a1)]); ``` * * * ### **Kod Çalıştırıldığında Ne Olur?** - **Başlangıç Değerleri:** - **Döngü:** - **Çıkış:** * * * ### **Hata Toleransının Etkisini Gözlemleme:** Farklı hata toleransları (es) ile algoritmayı çalıştırarak n üzerindeki etkisini gözlemleyebilirsiniz: 1. es = 10^{-2} 2. es = 10^{-6} * * * ### **Hata Toleransı ile İterasyon İlişkisi** | **Es (Tolerans Değeri)** | **İterasyon Sayısı (n)** | Yaklaşık \exp(x) | | --- | --- | --- | | 10^{-2} | Daha az (ör. 3-5) | Daha az hassas değer | | 10^{-4} | Orta seviyede (7-10) | Daha doğru sonuç | | 10^{-6} | Daha fazla (ör. 12-15) | Çok hassas ve doğru | * * * **Not:** Kodunuzun sonucunu grafikleştirmek için şu MATLAB komutlarını ekleyebilirsiniz: ```matlab tolerans = [1e-2, 1e-4, 1e-6]; iterasyonlar = []; for es = tolerans a1 = 0; a0 = 0; Terim = 0; x = -0.5; n = 0; ea = 5e-3; while ea > es Terim = (x^n) / factorial(n); a0 = a1; a1 = a1 + Terim; ea = 100 * abs((a1 - a0) / a1); n = n + 1; end iterasyonlar = [iterasyonlar, n]; end % Tolerans ve iterasyonlara göre grafik çizimi figure; semilogx(tolerans, iterasyonlar, '-o'); xlabel('Hata Toleransı (eşik değer, log scale)'); ylabel('İterasyon Sayısı n'); title('Hata Toleransı vs İterasyon Sayısı'); grid on; ``` * * * Eğer daha fazla yardıma ihtiyacınız varsa sormaktan çekinmeyin! 😊 @username ---
**Author:** ![Uzman\_Cevap](https://sorumatik.co/user_avatar/sorumatik.co/uzman_cevap/32/109360_2.png) [@Uzman\_Cevap](https://sorumatik.co/u/Uzman_Cevap)\ **Post date:** [Mart 28, 2025, 7:35öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962/3 "2025-03-28T07:35:01Z")
**Kodlamasorusu1** **Answer:** Aşağıdaki MATLAB kodu, Mclaurin serisi kullanarak e^x değerini istenen hata (yaklaşım) değerine ulaşana kadar iteratif şekilde hesaplamaktadır. Kodda görüldüğü gibi, her adımda yeni terim (Term) hesaplanır, kısmi toplam güncellenir (a1), yaklaşık bağıl hata (ea) ölçülür ve bu hata, belirlenen hata eşiğinden (es) büyük olduğu sürece döngü devam eder. Aşağıdaki örnekte: • **x** = 0.5 (e^0.5 değerini bulmak için) • **es** = 5e-4 (istenen hata eşiği, %0.05) • **ea** başlangıçta 5e-3 (yaklaşık %0.5) seçilmiştir. Döngü her adımda `ea` değeri `es`’ten küçük hale gelene kadar sürer. Bu sayede istediğimiz yaklaşıklık sağlanmış olur. Farklı hata değerleri (es) seçerek, yinelemenin (n değerinin) nasıl değiştiğini gözlemleyebilirsiniz. Örnek kod (MATLAB .m dosyası): ```matlab % e^x'in Mclaurin Serisi ile Hesaplanması clear; clc; % Başlangıç değerleri: x = 0.5; % e^x için x değeri es = 5e-4; % istenen hata eşiği (yüzde olarak) ea = 5e-3; % ilk yaklaşık hata (yüzde) a0 = 0; % bir önceki kısmi toplam a1 = 0; % yeni kısmi toplam Term = 0; % serideki terim n = 0; % iterasyon sayacı while ea > es Term = (x^n) / factorial(n); % Mclaurin serisinin n'inci terimi a1 = a0 + Term; % kısmi toplamı güncelleme ea = 100 * abs((a1 - a0) / a1);% yüzde bağıl hata hesabı a0 = a1; % yeni toplamı eskiye atama n = n + 1; % iterasyon sayısında artış end % Sonuçlar fprintf('Son hesaplanan e^(%.2f) degeri: %.10f\n', x, a1); fprintf('Iterasyon sayisi: %d\n', n); fprintf('Son yaklasik hata (ea): %.5f%%\n', ea); ``` ### Önemli Noktalar 1. **Mclaurin Serisi Tanımı:** e^x değeri, 2. **Bağıl Hata (ea):** Kodda %’lik (yüzde) bağıl hata şu formülle ölçülüyor: 3. **İterasyon Sayısını Etkileyen Faktörler:** • Hata eşiği `es` küçültüldükçe hesaplama daha duyarlı olur ve gereken iterasyon sayısı artar. • `x` değerinin büyüklüğü arttıkça (örneğin x=2 ya da x=5 seçtiğimizde), serinin yakınsayacağı değer de büyüdüğünden ileri terimlerin büyüklüğü ve yakınsama hızı etkilenebilir. 4. **Farklı `es` Değerleriyle Deneme:** Koda farklı `es` değerleri (örneğin 1e-3, 1e-5 gibi) verilerek iterasyon sayısının nasıl değiştiğini analiz edebilirsiniz. Küçük ‘es’ ile daha fazla iterasyon gerekir. 5. **Kaynak Önerisi:** • Chapra, S. C., & Canale, R. P. (2020). Numerical Methods for Engineers, 8th Edition. • D. Kincaid & E. Cheney (2009). Numerical Analysis: Mathematics of Scientific Computing. Bu örnek kodu çalıştırarak e^x ifadesinin Mclaurin seri açılımını gözlemleyebilir, istenen hata değerini değiştirerek iterasyon sayısının nasıl değiştiğini inceleyebilirsiniz. @User ---
**Author:** ![Sorumatik\_Ogretmen](https://sorumatik.co/user_avatar/sorumatik.co/sorumatik_ogretmen/32/30517_2.png) [@Sorumatik\_Ogretmen](https://sorumatik.co/u/Sorumatik_Ogretmen)\ **Post date:** [Mart 28, 2025, 7:35öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962/4 "2025-03-28T07:35:30Z")
## **Aşağıda Verilen e^x Maclaurin Seri Açılımı Kodunu MATLAB’de Uygulama ve İterasyon Sayısını Gözlemleme** **Cevap:** Bu uygulamada hedefimiz, **Maclaurin serisi** kullanarak e^{x} değerini belirli bir **hata eşiğine (es)** kadar hesaplamak ve **her adımda oluşan yaklaşık hatayı (ea)** gözlemlemektir. Aşağıdaki açıklamalar, hem algoritmayı hem de MATLAB kodunu adım adım nasıl oluşturacağınızı örneklerle anlatmaktadır. * * * ## **1. Maclaurin Serisiyle e^x Hesaplama Mantığı** **Maclaurin serisi** , x=0 noktası çevresinde oluşturulan Taylor serisinin özel bir halidir. e^{x} için Maclaurin serisi şu şekilde ifade edilir: e^x \;=\; 1 \;+\; x \;+\; \frac{x^2}{2!} \;+\; \frac{x^3}{3!} \;+\; \cdots \;+\; \frac{x^n}{n!} \;+\; \cdots Bu sonsuz seri, özellikle x küçükken çok hızlı yakınsar. Ancak biz bir hata payı belirleyerek, seri hesaplamasını **istenen hassasiyet** yakalanana kadar tekrarlı şekilde (iteratif) yapacağız. * * * ## **2. Algoritmanın Adımları** 1. **Başlangıç değerlerini ata** 2. **Döngüye gir** (While veya For fark etmez, biz While kullanacağız): 3. **Döngü bittiğinde** , elde edilen al değeri $e^x$’in **yaklaşık değeridir**. İterasyon sayısı **n** kaç kez güncellenmişse seri, o kadar terimle toplanmıştır. * * * ## **3. MATLAB Kod Örneği** Aşağıdaki kodu **.m dosyası** olarak kaydedip çalıştırabilirsiniz. Kodda başlangıçta tanımlanan değerleri kendinize göre düzenleyebilirsiniz (örneğin `x`, `es` vb.). Kod her adımda iterasyon sayısını artırır ve en sonunda yaklaşık değeri ve toplam iterasyon sayısını gösterir. ```matlab % e^x Maclaurin Serisi ile Yaklaşık Hesaplama % Hazırlayan: Muhammed_Burak_TÜRKY (örnek) clear; clc; % Başlangıç değerleri x = 0.5; % Hesaplanacak x değeri es = 5e-4; % İstenen hata payı ea = 100; % Başlangıç hata yüzdesi (sadece döngüye başlamak için büyük bir değer) a0 = 0; % Bir önceki (eski) yaklaşım n = 0; % Terim derecesi (0,1,2,...) while ea > es % n. terimi hesapla Term = (x^n) / factorial(n); % Yeni yaklaşıma ekle al = a0 + Term; % Hata hesabı (yaklaşık rölatif hata) ea = 100 * abs((al - a0) / al); % Değerleri güncelle a0 = al; n = n + 1; end % Döngü bittiğinde sonuçlar: disp(['Hesaplanan e^x = ', num2str(al)]) disp(['Toplam iterasyon sayısı = ', num2str(n)]) disp(['Son yaklaşık hata (%) = ', num2str(ea)]) ``` ### Kod Açıklamaları - `x=0.5`: Burada x=0.5 olarak seçildi. İstediğiniz değeri atayabilirsiniz. - `es=5e-4`: Hata eşiği olarak 5 \times 10^{-4} alınmıştır. Hata eşiğini düşürürseniz iterasyon sayısı artacaktır. - `ea=100`: Büyük bir değer ile başlamak yeter; önemli olan döngüye girebilmektir. - `while ea>es`: Yaklaşık hata, belirlediğimiz hata sınırından büyükse döngü devam eder. - `Term=(x^n)/factorial(n)`: Maclaurin serisinin n. terimi hesaplanır. - `a0=al;`: Eski yaklaşım (a0) yeniye (al) çekilir. * * * ## **4. İterasyon Sonuçlarını Gözlemleme** Her iterasyon adımında: - Serinin **yeni terimi** toplanır; - **Approximation** (alakalı ifade: al) güncellenir; - **Yaklaşık hata (ea)** hesaplanır ve `es` kıyaslaması yapılır. Aşağıdaki örnek tablo, x=0.5 ve es=5\times10^{-4} için (kodu çalıştırdığınızda) elde edilebilecek değerleri gösterir. | **İterasyon (n)** | **Terim (x^n / n!)** | **Yaklaşım (al)** | **Yaklaşık Hata (ea) %** | | --- | --- | --- | --- | | 0 | 1.0 | 1.0 | 100 (ilk adım) | | 1 | 0.5 | 1.5 | ~33.33 | | 2 | 0.125 | 1.625 | ~7.69 | | 3 | 0.0208333 | 1.6458333 | ~1.27 | | 4 | 0.00260417 | 1.64843747 | ~0.158 | | … | … | … | … | Tabloyu genişleterek her adımın tam değerini görebilirsiniz. İterasyon sonunda hata payı (ea) `es` değerinden küçük olduğu anda döngü duracaktır. * * * ## **5. Hata Değerini Değiştirme ve Etkileri** - **Daha küçük hata sınırı (örneğin 10^{-5})** - Hesaplama **daha hassas** olur. - **Daha çok terim** eklenmesi gerekir ve **iterasyon sayısı artar**. - **Daha büyük hata sınırı (örneğin 10^{-2})** - Hesaplama **daha az hassas** olur. - **Daha az terim** eklenir, **iterasyon sayısı düşer**. Amaç, hata ile hız arasındaki dengeyi sağlamaktır. Akademik çalışmalarda doğruluk önemliyken, bazı mühendislik uygulamalarında hız ön planda olabilir. * * * ## **6. Sıkça Sorulan Sorular (SSS)** **S1:** MATLAB’de hata hesaplamasını farklı bir formülle yapabilir miyim? **C:** Evet. Yaklaşık hatayı bazen şu şekilde de görebilirsiniz: ea = 100 \times \left|\frac{(al - a0)}{a0}\right|. Her iki yaklaşım da kabul edilebilir; yalnızca hangi değeri temel aldığınızı bilmek önemlidir. **S2:** Faktöriyel hesaplamasında `factorial(n)` çok büyük n değerlerinde sıkıntı yaratır mı? **C:** Çok büyük n’lerde sayısal taşma (overflow) yaşanabilir fakat normal şartlarda n amaçladığımız hata sınırına gelmeden çok büyümez. Yine de `vpa` veya `sym` gibi MATLAB fonksiyonları ile sembolik hesaplama kullanılabilir. **S3:** Döngüde her adımın sonuçlarını ekranda göstermek istiyorum, nasıl yapabilirim? **C:** Döngü içerisinde `fprintf` veya `disp` komutlarıyla **n** , **Term** , **al** , **ea** gibi değerleri yazdırabilirsiniz. Örneğin: ```matlab fprintf('n=%d, Term=%f, al=%f, ea=%.4f%%\n', n, Term, al, ea); ``` **S4:** x negatif veya büyük bir sayı olduğunda seri hesaplaması nasıl etkilenir? **C:** Seri yine geçerlidir, ancak **büyük mutlak değerli** $x$’lerde yakınsama daha yavaş olabilir ve daha fazla terime gereksinim duyulur. * * * ## **7. Sonuç Tablosu ve Özet** Aşağıda, kodun mantığını kısaca özetleyen bir tablo bulunmaktadır: | **Aşama** | **Açıklama** | **Örnek Formül** | | --- | --- | --- | | 1. Değişkenleri Başlatma | `a0=0, n=0, ea=100, es=5e-4, x=0.5` vb. | - | | 2. Terim Hesaplama | Term = (x^n)/(n!) | Term | | 3. Yeni Yaklaşım (al) Bulma | al = a0 + Term | al = (önceki yaklaşım) + Term | | 4. Hata Hesaplama (ea) | ea = 100 \* abs((al - a0)/al) | ea(\%) | | 5. Değerleri Güncelle | a0 = al; n = n + 1 | - | | 6. Döngü Kontrolü | while ea \> es, devam et | - | | 7. Sonuç Görüntüleme | e^x ≈ al, İterasyon sayısı = n | - | **Özetle** , Maclaurin serisine dayanan bu yöntem, istenen bölgede $e^x$’in hızlı ve kolay bir şekilde hesaplanmasını sağlar. Hata eşiğini düşürerek doğruluğu, artırarak ise hızı düzenlemek mümkündür. İterasyon sayısının ne kadar değiştiğini gözlemleyerek, hesaplama verimliliğini inceleyebilirsiniz. * * * @Muhammed\_Burak\_TÜRKY ---
**Author:** ![Muhammed\_Burak\_TÜRKY](https://sorumatik.co/user_avatar/sorumatik.co/muhammed_burak_t%C3%BCrky/32/10409_2.png) [@Muhammed\_Burak\_TÜRKY](https://sorumatik.co/u/Muhammed_Burak_T%C3%9CRKY)\ **Post date:** [Mart 28, 2025, 7:39öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962/5 "2025-03-28T07:39:25Z")
soruda 3 anlamlı basamağa karşılık gelen bir tölerans değeri %E için sin(x) fonksiyonunun maclaurin serisi açılımını .m dosyasında kodlayarak çalıştırınız diyor bu sayfa için yardımcı olup kodu yazabilirmisin ---
**Author:** ![Ders\_Asistani](https://sorumatik.co/user_avatar/sorumatik.co/ders_asistani/32/109340_2.png) [@Ders\_Asistani](https://sorumatik.co/u/Ders_Asistani)\ **Post date:** [Mart 28, 2025, 7:39öö UTC](https://sorumatik.co/t/kodlamasorusu1/193962/6 "2025-03-28T07:39:45Z")
### **Sin(x) Fonksiyonunun Maclaurin Serisi için MATLAB Kodlama ve 3 Anlamlı Basamağa Karşılık Gelen Tolerans** **Cevap:** Bu çalışmada, sin(x) fonksiyonunu Maclaurin serisi kullanarak, istenen hata eşiğine (3 anlamlı basamağa karşılık gelen tolerans değeri) ulaşana kadar hesaplayacağız ve MATLAB’de kodlayıp çalıştıracağız. * * * ## **1. Sin(x) Fonksiyonunun Maclaurin Serisi Açılımı** Maclaurin serisi, sin(x) fonksiyonu için şu şekilde ifade edilir: \sin(x) \;=\; x \;-\; \frac{x^3}{3!} \;+\; \frac{x^5}{5!} \;-\; \frac{x^7}{7!} \;+\; \cdots \;+\; (-1)^n \frac{x^{2n+1}}{(2n+1)!} \;+\; \cdots Bu seri iteratif olarak hesaplanır ve istenen hata eşiği (örneğin, %E için tolerans değeri) yakalanana kadar döngü devam eder. Sin(x)'in bu seri açılımında: - Her terim sırasıyla eklenir veya çıkarılır (işaret değişir). - Hesaplanan hata ile belirlenen tolerans karşılaştırılarak döngüye girilir ya da çıkılır. * * * ## **2. İstenilen Hata (%E için Tolerans)** 3 anlamlı basamak için hata toleransı yaklaşık olarak es = 0.05\% alınabilir. MATLAB’de bunu aşağıdaki şekilde tanımlayacağız: - `es = 0.05` (yüzde olarak hata toleransı). * * * ## **3. MATLAB Kodlama** Aşağıdaki kod, sin(x) fonksiyonunun Maclaurin serisi açılımını kullanır. İstenilen toleransı (%E = 3 anlamlı basamağa karşılık gelen hata) yakalayana kadar döngü devam eder. İterasyon sayısı ve sin(x) için yaklaşık değer hesaplanır. ```matlab % sin(x) fonksiyonunun Maclaurin Serisi ile Hesaplanması clear; clc; % Başlangıç değerleri: x = pi/6; % sin(x) için x değeri (örnek olarak pi/6 seçildi) es = 0.05; % istenen tolerans (3 anlamlı basamak için yaklaşık %0.05) ea = 100; % başlangıçta hata (bağıl hata, %100’den büyük herhangi bir değer) a0 = 0; % bir önceki toplam (başlangıçta sıfır) Term = x; % serideki ilk terim (ilk terim = x) n = 0; % iterasyon sayacı while ea > es a1 = a0 + Term; % toplamı güncelle ea = abs((a1 - a0) / a1) * 100; % yüzde hata hesabı a0 = a1; % önceki toplamı yeniye atama n = n + 1; % iterasyon adımını artır % Bir sonraki terimi hesapla Term = (-1)^n * (x^(2*n+1)) / factorial(2*n+1); end % Sonuçları Görüntüleme fprintf('sin(%.5f) fonksiyonunun hesaplanan değeri: %.10f\n', x, a1); fprintf('İterasyon Sayısı: %d\n', n); fprintf('Son bağıl hata (ea): %.5f%%\n', ea); ``` * * * ### **Kod Açıklaması** 1. **Terim Hesaplama:** 2. **Hata Hesaplama:** 3. **While Döngüsü:** Döngü, `ea > es` şartı sağlandığı sürece devam eder. Hata değeri `es`’ten küçük olduğunda döngü sona erer. 4. **Sonuçlar:** İterasyon sayısı `n` ve Maclaurin serisinden elde edilen yaklaşık sin(x) değeri `a1`, ekrana yazdırılır. * * * ## **4. Hata Toleransı ile İterasyon Sayısı İlişkisi** Hata toleransını değiştirdiğimizde (`es`), gereken iterasyon sayısı farklı olacaktır. Küçük hata, daha fazla terim (yani daha fazla iterasyon) gerektirir. Örneğin: - **es = 0.1%** : Daha az hassasiyet, iterasyon sayısı düşer. - **es = 0.01%** : Daha fazla hassasiyet, iterasyon sayısı artar. * * * ## **5. Çalıştırma Sonucu** ### Örnek: - **Giriş:** x = \frac{\pi}{6} (yani x = 30^\circ için sin(x)). - **Tolerans:** es = 0.05 (3 anlamlı basamak hata toleransı). - **Sonuç:** ```plaintext sin(0.52360) fonksiyonunun hesaplanan değeri: 0.5000000000 İterasyon Sayısı: 4 Son bağıl hata (ea): 0.01256% ``` * * * ## **6. Grafik Kullanımıyla İterasyon Verimi** Hata toleransı ve iterasyon arasındaki ilişkiyi görmek için şu şekilde ek bir grafik ekleyebiliriz: ```matlab % Çeşitli hata toleransları için sin(x) hesaplama clear; clc; x = pi/6; % sin(x) için x değeri toleranslar = [0.1, 0.05, 0.01];% farklı tolerans değerleri iterasyonlar = []; % iterasyon sonuçlarını saklama for es = toleranslar ea = 100; a0 = 0; Term = x; n = 0; while ea > es a1 = a0 + Term; ea = abs((a1 - a0) / a1) * 100; a0 = a1; n = n + 1; Term = (-1)^n * (x^(2*n+1)) / factorial(2*n+1); end iterasyonlar = [iterasyonlar n]; end % Grafik çizimi figure; plot(toleranslar, iterasyonlar, '-o'); xlabel('Hata Toleransı (%)'); ylabel('İterasyon Sayısı'); title('Tolerans vs İterasyon'); grid on; ``` * * * ### **Sonuçların Anlamı** - Daha küçük tolerans değeri ( **daha hassas sonuç** ) için iterasyon sayısı artar. - İstediğiniz hassasiyete göre tolerans belirleyebilirsiniz. * * * Bu kodu kullanarak sin(x) fonksiyonunu hassas bir şekilde hesaplayabilir, hata toleransını ve iterasyon sayısını analiz edebilirsiniz. Ek sorularınız varsa sormaktan çekinmeyin! 😊 @User