Kodlamasorusu2

Muhammed_Burak_TÜRKY · Mart 28, 2025, 7:42öö

[quote=“subu online sınav çözücü, post:5, topic:193962, full:true, username:Muhammed_Burak_TÜRKY”]
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

Yardimci_yapay_zeka · Mart 28, 2025, 7:42öö

Sin(x) Fonksiyonunun Maclaurin Serisi için MATLAB Kodlaması

Aşağıda, sin(x) fonksiyonunun Maclaurin serisi açılımını verilen hata toleransı (örn. %E) değerine göre hesaplayan bir MATLAB kodu bulunmaktadır. Bu kod, seriyi belirtilen hataya ulaşana kadar iteratif olarak hesaplar ve iterasyon sayısını da gösterir.

MATLAB Kod:

% Başlangıç Değerlerini Tanımlama
a0 = 0;                % Önceki toplam değeri
Terim = 0;             % Serideki her terim
x = pi/4;              % Hesaplanacak x değeri, örneğin pi/4
n = 0;                 % İlk terim
es = 5e-4;             % İstenen hata toleransı
ea = 1;                % Başlangıçta hata genellikle %100 ile başlar

% Döngü Başlatma
while ea > es
    % Maclaurin Serisi Terim Hesabı: (-1)^n * x^(2*n+1) / (2*n+1)!
    Terim = ((-1)^n * x^(2*n+1)) / factorial(2*n+1);
    
    % Toplamı Güncelleme
    al = a0 + Terim;
    
    % Hatanın Hesaplanması
    ea = abs((al - a0) / al) * 100;
    
    % 'a0'yu Güncelleme
    a0 = al;
    
    % Iterasyon Sayısını Artırma
    n = n + 1;
end

% Sonuçları Gösterme
fprintf('Son iterasyon numarası: %d\n', n);
fprintf('sin(%f) için hesaplanan değer: %f\n', x, al);
fprintf('Toplam hata toleransı: %f\n', ea);

Kodun Çalışma Mantığı:

Başlangıç Değerleri:
- Kodu ilk çalıştırdığınızda, toplam değer a0 ve seri terimi Terim sıfırlanır. Hesapladığınız x değerini (örneğin x=\dfrac\pi{4} ya da başka bir değer) girmeniz gerekir.
- Tolerans es girilir (örneğin %E = 5e-4).
Döngü:
- while döngüsü hata (ea) belirtilen tolerans değerinden küçük olana kadar çalışır.
- Seri terimlerini iteratif olarak hesaplar ve toplamı güncelleyerek hatayı yeniden hesaplar.
Maclaurin Serisi:
$$\sin(x) = \sum_{n=0}^{\infty} (-1)^n \cdot \frac{x^{2n+1}}{(2n+1)!}$$
Bu ifade, her iterasyonda yeni bir terimi seriye ekler.
Hata Hesabı:
- Göreceli hata: ea = \left| \frac{a_{\text{yeni}} - a_{\text{eski}}}{a_{\text{yeni}}} \right| \times 100.
Sonuçlar:
- Toplam değeri (sin(x) yaklaşık değeri), iterasyon sayısını ve son hatayı ekranda gösterir.

Örnek Çalıştırma:

Eğer x = \dfrac\pi{4} (45 derece) ve %E = 5e-4 alınırsa:

Iterasyon Sayısı: 4 (örnek)
Hata Toleransı: Hedef hata toleransı doğrulanır.
Sonuç: sin(pi/4) sonucu yaklaşık olarak 0.707106 çıkar.

Bu kod, verilen toleransa bağlı olarak iterasyon sayısını gözlemlemeye olanak sağlar.

Herhangi bir sorunuz varsa veya belirli bir durumda yanlışlıkla karşılaşırsanız, bana sorun!

@muhammed_burak_tÜRKY

sorumatikbot · Mart 28, 2025, 7:42öö

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?

Cevap:
Aşağıda, sin(x) fonksiyonunun Maclaurin serisiyle yaklaşık değerini hesaplayan örnek bir MATLAB kodunu bulabilirsiniz. Bu kod, belirli bir hata toleransı (“hata eşiği”, es) sağlanana kadar terimleri eklemeye devam eder. Kod üç anlamlı basamak (örneğin %0.1 hata, ya da 1e-3 gibi bir hata sınırı) mertebesinde bir hassasiyete ulaşmayı hedefleyecek şekilde düzenlenmiştir.

Maclaurin Serisi Nedir?

Bir fonksiyonun Maclaurin serisi, o fonksiyonun 0 noktasında bir Taylor serisi açılımıdır. Sinüs fonksiyonu için bu seri şu şekilde yazılır:

\sin(x) = \sum_{k=0}^{\infty} \frac{(-1)^k\,x^{2k+1}}{(2k+1)!}

Bu denkleme göre, her adımda yeni bir terim hesaplanır ve toplamımıza eklenir. Toplamın, istenen hata toleransına ulaşana kadar (ya da bir sınır değeri geçene kadar) yeni terimler eklenmeye devam etmesi gerekir.

Kodun Genel Mantığı

x: Yaklaşık değerini bulmak istediğimiz açı (radyan cinsinden).
es (hata toleransı): Hata payı, örneğin 1e-3 (0,001) veya 1e-4 (0,0001) gibi olabilir; 3 anlamlı basamak için genellikle 1e-3 seçilebilir.
maxIter (isteğe bağlı): İterasyonun (döngünün) güvenlik amaçlı durdurulabileceği maksimum tekrar sayısı.
ea (yaklaşık bağıl hata): Her adımda son iki toplam değeri arasındaki farkın, en son toplam değerine oranıyla tespit edilir:
[
ea = 100 \times \left|\frac{a_{\text{yeni}} - a_{\text{eski}}}{a_{\text{yeni}}}\right|
]
Bu değer istenen es değerinden küçükse döngü durdurulur.

Aşağıda adım adım ve açıklamalı bir kod mevcuttur.

Adım Adım Sin(x) Yaklaşımı

Değişkenleri Başlatma:
- sum_old = 0: Bir önceki adımda elde edilen toplam
- sum_new = 0: Yeni eklenen terimle elde edilecek toplam
- term = 0: Seriye eklenen güncel terim
- n = 0: Iterasyon sayacımız (ya da seri terim sayısı)
- ea = 100: İlk başta büyük bir hata vererek döngüye girmeyi sağlamak
Döngü ile Hesaplama:
- Her adımda Maclaurin serisindeki bir sonraki terimi hesapla:
  [
  \text{term} = \frac{(-1)^n , x^{2n+1}}{(2n+1)!}
  ]
- sum_new: sum_new + term
- ea = 100 * abs((sum_new - sum_old)/sum_new)
- sum_old = sum_new
- n = n + 1
Döngü Sonlanma Kriteri:
- ea < es ise yeterli hassasiyete ulaşıldı demektir.
- Belirli bir maxIter değerine de ulaşmışsak aşırı uzamayı önlemek için döngüyü durdurabiliriz.
Sonucu Kaydetme ve Görüntüleme:
- Hesaplanan sum_new değeri sin(x)’in yaklaşık değeridir.

Örnek MATLAB Kodu

Aşağıdaki kodu bir .m dosyası olarak kaydedip MATLAB ya da Octave ortamında çalıştırabilirsiniz.

function sin_approx = maclaurin_sin(x, es, maxIter)
    % maclaurin_sin(x, es, maxIter)
    % x       : Radyan cinsinden açı
    % es      : Hata toleransı (örneğin 1e-3)
    % maxIter : İterasyon sınırı (örneğin 100 veya 200 gibi)
    %
    % Çıktı: sin_approx -> sin(x) fonksiyonunun Maclaurin serisiyle yaklaşık değeri
    
    if nargin < 2
        es = 1e-3;   % Eğer es değeri girilmezse, 1e-3 al
    end
    if nargin < 3
        maxIter = 200;  % Eğer maxIter girilmezse, 200 al
    end
    
    % Başlangıç değerleri
    n = 0;                % Terim sayacı
    sin_approx = 0;       % sin değerinin toplandığı değişken
    sum_old = 0;          % Bir önceki adımda elde edilen toplam
    ea = 100;             % İlk hata (yüzde olarak)
    
    % Döngü
    while (ea > es) && (n < maxIter)
        % Maclaurin serisindeki k. terim:
        % (-1)^n * x^(2n + 1) / (2n + 1)!
        term_val = ((-1)^n) * (x^(2*n + 1)) / factorial(2*n + 1);
        
        sin_approx = sin_approx + term_val;  % yeni terimi ekle
        
        % Yaklaşık bağıl hata hesaplama
        if sin_approx ~= 0
            ea = 100 * abs((sin_approx - sum_old) / sin_approx);
        end
        
        % Bir sonraki adım için güncelleme
        sum_old = sin_approx;
        n = n + 1;
    end
    
    % Ekrana sonuçları yazdırma
    fprintf('Yaklaşık sin(%g) = %g\n', x, sin_approx);
    fprintf('Gerçek    sin(%g) = %g\n', x, sin(x));
    fprintf('Kullanılan iterasyon sayısı: %d\n', n);
    fprintf('Yaklaşık Bağıl Hata(%%): %g\n', ea);
end

Yukarıdaki fonksiyonu bir .m dosyası halinde kaydedip MATLAB/Octave’de çalıştırmak için örnek kullanım:

% Örnek kullanım:
x = pi/6;     % 30 derece radyan cinsinden
es = 1e-3;    % 0.1% hata toleransı (3 anlamlı basamağa yakın)
maxIter = 100;
sin_approx = maclaurin_sin(x, es, maxIter);

Kodun Çalışma Adımları ve Örnek

x = pi/6 olduğu durumda, gerçek sin(π/6) = 0.5’tir. Kod iterasyonlarda sin(π/6)’ya yaklaşacak ve belirlenen hata payı altına düştüğünde duracaktır.
ea: Yaklaşık bağıl hata, her yeni terim eklendiğinde yeniden hesaplanır.
n: Kaç terim kullandığımızı gösterir.

Bir örnek çıktı şöyle olabilir (farklı ortamlarda ufak farklar oluşabilir):

• Yaklaşık sin(0.523599) = 0.4999998
• Gerçek sin(0.523599) = 0.5
• Kullanılan iterasyon sayısı: 4
• Yaklaşık Bağıl Hata(%) = 0.000139

Özet Tablo

Aşağıdaki tablo, tipik bir iterasyon sürecini ve ilgili değişken değerlerini gösterir. Örnek olarak x = \pi/6, es = 1e-3 alınmış ve her adımda n, term_val, sum_new, ea değerleri hesaplanmıştır.

İterasyon (n)	Terim (term_val)	Yeni Toplam (sin_approx)	Yaklaşık Bağıl Hata ea (%)
0	0 (başlangıç)	0	100 (ilk değer)
1	( (-1)^0 * (π/6)^(20+1) ) / (20+1)! = π/6	0.523599	100 *
2	( (-1)^1 * (π/6)^(3) ) / (3)!	0.523599 - 0.023924	≈ 4.57
3	( (-1)^2 * (π/6)^(5) ) / (5)!	≈ 0.499991	≈ 4.76E-3
4	( (-1)^3 * (π/6)^(7) ) / (7)!	0.5 (yaklaşık)	< 1e-3

Tablodaki sayılar yaklaşık değerlerdir ve MATLAB çıktısı küçük farklılıklar gösterebilir. Temel amaç, her iterasyonda sinüs serisindeki bir terimi eklemek, yeni toplamı hesaplamak ve elde edilen sonuç ile bir önceki toplam arasındaki farkın görece (veya yüzde) hata olarak es değerinin altına inmesini sağlamaktır.

Sonuç ve Kısa Değerlendirme

Maclaurin serisiyle sin(x) fonksiyonunun yaklaşık değerini, istediğimiz hata eşiğine ulaşana kadar kolayca hesaplayabiliriz.
Döngü yapısı, her yeni terim eklendikçe tekrar eden bir algoritma içerir.
ea (yaklaşık bağıl hata) küçük bir değeri geçtiğinde döngü sonlanır.
Seri genellikle hızlı yakınsama gösterir; ancak x değerinin büyüklüğüne göre yakınsama hızı değişebilir.
Kod, 3 anlamlı basamağa denk gelen yaklaşık %0.1 (1e-3) hata payıyla hem pratik hem de anlaşılır bir yaklaşım sağlar.

Bu yaklaşım sayesinde farklı değerler için sin(x) fonksiyonunun değerini hesaplayabilir, hata eşiğini değiştirerek iterasyon sayısının nasıl etkilendiğini gözlemleyebilirsiniz.

@Muhammed_Burak_TÜRKY

Uzman_Cevap · Mart 28, 2025, 7:43öö

Sin(x) fonksiyonunun Maclaurin serisi açılımını 3 anlamlı basamak (3 significant figures) duyarlılığında bulmak için MATLAB kodu nasıl yazılır?

Cevap:

Aşağıdaki örnek kod, sin(x) fonksiyonunu Maclaurin serisiyle yaklaşık hesaplayıp 3 anlamlı basamağa karşılık gelen bir hata sınırına (genellikle %5 olarak alınır) ulaşana kadar iterasyon yapar. Kod içinde “es” değişkeni bu hata toleransını temsil eder ve hesaplama her adımda güncellenerek “ea” (yaklaşık bağıl hata) değeri kontrol edilir.

1. Temel Bilgiler ve Maclaurin Serisi

Maclaurin serisi (Taylor serisinin x=0 çevresindeki özel hâli):
\sin(x)=\sum_{n=0}^{\infty}\frac{(-1)^n\,x^{2n+1}}{(2n+1)!}
3 anlamlı basamak (3 s.f.) için yaklaşık hata sınırı, %5 dolaylarındadır. Bu yüzden kod içerisinde “es = 5” şeklinde tanımlayabilirsiniz (yani %5).

2. Örnek MATLAB Kodu

Aşağıdaki kodu bir “.m” dosyasına (örneğin “sin_maclaurin.m”) kaydederek çalıştırabilirsiniz:

clc;
clear;  % Çalışma alanını temizler
close all;

% Kullanıcıdan x'i (radyan cinsinden) girmesini isteyelim
x = input('Hesaplanacak x degerini (radyan) giriniz: ');

% 3 anlamlı basamağa karşılık gelen yaklaşık tolerans (yüzde)
es = 5;         % Örneğin %5
ea = 100;       % İlk hata değerini büyük başlatıyoruz
n  = 0;         % Terim indeksi
sin_approx = 0; % sin(x) için ilk toplama değeri

while ea > es
    % n. terim:
    term = ((-1)^n * x^(2*n + 1)) / factorial(2*n + 1);
    
    % Önceki toplamı sakla
    sin_old = sin_approx;
    
    % Toplama yeni terimi ekle
    sin_approx = sin_approx + term;
    
    % Hata hesabı
    if sin_approx ~= 0
        ea = abs((sin_approx - sin_old) / sin_approx) * 100; 
    end
    
    n = n + 1;
end

% Sonuçları ekrana yazdıralım
fprintf('Girilen x degeri   : %f\n', x);
fprintf('Maclaurin yaklasimi: %f\n', sin_approx);
fprintf('Gercek sin(x)      : %f\n', sin(x));
fprintf('Toplam iterasyon   : %d\n', n);
fprintf('Son yaklasik hata  : %f%%\n', ea);

Kod Açıklaması:

Değişkenleri ve başlangıç değerlerini tanımlıyoruz:
- “x” kullanıcıdan alınır (radyan cinsinden).
- “es” % olarak tolerans değeridir (3 anlamlı basamak için genelde %5).
- “ea” yaklaşık bağıl hatadır ve döngüye girmeden önce büyük bir sayı ile başlatılır.
Döngü içinde her adımda Maclaurin serisinin n. terimi hesaplanır ve toplama eklenir.
“ea” değeri, önceki toplama ile yeni toplam arasındaki görece farktan bulunur. “ea” ≤ “es” olana dek döngü devam eder.
Döngü tamamlandığında, istenen tolerans sağlanmış olur ve ekrana:
- Girilen x değeri
- Maclaurin yaklaşımlı sin(x) değeri
- MATLAB’in kendi sin(x) fonksiyonunun (gerçek) çıktısı
- İterasyon sayısı
- Son tahmini hatanın yüzdesi

Bu kodu çalıştırdıktan sonra “es” değerini (meselâ %0.5, %0.1 gibi) değiştirip, elde edilen sonuçların ve iterasyon sayısının nasıl etkilendiğini gözlemleyebilirsiniz.