Nesne

1.0E: Alıştırmalar - Matematik


1.0: Egzersizler

(0) Büyüklüğün logaritmalarla ilgili olduğunu biliyor muydunuz?


Doğru fikre sahip gibisin.

Herhangi bir pozitif tamsayıya yükseltilen 10$'ın arkasında o kadar çok $s olan 1$ olduğunu bilmelisiniz. Böyle

Sınırlı görüntüleme ve depolama alanını iyi kullanmak için sadece kısa bir gösterimdir.

Üstel veya bilimsel gösterim olarak adlandırılan 10 tabanlı gösterimde kullanılan dize ve kodlanmış rasyonel sayı $ (underbrace_m> ,,, mboxunderbrace_k>)_ <10>= m cdot 10^k $

rakamlar $d in < 0, ldots, 9 >$, üstel sembol "E" veya "e", rasyonel $|m| < 10$ ve tamsayı $k$.

Üs, $e^x$ üstel işleviyle karıştırılmamalıdır.

Ayrıca bazı problemler için "büyüklük sırası" (yani 10$^k$) yeterince iyidir ve tüm rakamların bilgisi gerekli değildir.

Örnekte "1e+11" dizesi $1 cdot 10^ <+11>= 10^ <11>= 1underbrace<00000000000>_<11 , "0" mbox sayısı anlamına gelir>$

Ortaya çıkan sayının, okulda öğrenilen 10 tabanlı konumsal sistem gösterimi olan, genellikle daha tanıdık olan bir diziyle de verildiğine dikkat edin.

Başka bir örnek: "0.27e-15", .27 cdot 10^ <-15>= 0.underbrace<000000000000000>_<15 , "0" mbox sayısı anlamına gelir>25$


11.1 ALIŞTIRMA 1

Runge-Kuta

  1. Çevrilen programın listesi.
  2. Dört test senaryosunun tam bir çalışmasından listeleme (örneğin UNIX komut dosyasını kullanarak)

Görev, diferansiyel denklemi çözmektir. y'(x) = x 2 + günah(xy) başlangıç ​​değerini kullanarak Runge-Kutta yöntemiyle y(1) = 2 gidiyor x = 2 ve yukarıdaki adım boyutlarını kullanarak. Runge-Kutta yönteminin formülleri örneğin alıştırma 8'in açıklamasındadır. Bu programı çalıştırmak istiyorsanız, DEC UNIX sisteminde çalışırken ilk satırı aşağıdaki genişletilmiş satırla değiştirmeniz gerekir, ancak Sun'da değil. Solaris sistemi.


S 1.63

[2 m^2sağ ok cm^2 umber ]

Birimlerin karesi için dönüştürme faktörünün karesinin alınması gerektiğine dikkat edin.

[2 m^2cdot dfrac<100cm^2><2m^2>=1cdot 10^2cm^2 umber ]

Kontrol edin: Cevabın birimleri doğrudur ve büyüklük anlamlıdır. Birim santimetre bir metreden küçüktür, bu nedenle santimetre kare cinsinden değer metre kare cinsinden daha büyük olmalıdır.

İzotoplar, aynı sayıda protona sahip ancak nötron sayıları farklı olan atomlardır. Aşağıdaki izotopların her birinin kimyasal sembollerini yazın:

  1. 18 nötronlu klor izotopu
  2. 20 nötronlu klor izotopu
  3. 20 nötronlu kalsiyum izotopu
  4. 11 nötronlu neon izotop
  1. Periyodik tablodan verilen elementin atom numarasını belirleyin.
  2. İzotopun kütle numarasını hesaplamak için soruda verilen nötron sayısını atom numarasına ekleyin.
  3. Kütle numarası kimyasal sembolün sol üst köşesinde, atom numarası ise sol alt köşede gösterilecektir.

Yardımcı ipuçları:

  1. [_<17>^<35> extrm umara yok ]
  2. [_<17>^<37> extrm umara yok ]
  3. [_<20>^<40> extrm umara yok ]
  4. [_<10>^<21> extrm umara yok ]

Listelenen her izotoptaki proton ve nötron sayısını verin

  1. [_<19>^<41> extrm umara yok ]
  2. [_<4>^<11> extrm umara yok ]
  3. [_<22>^<45> extrm umara yok ]
  4. [_<8>^<16> extrm umara yok ]

Büyük sayıyı alın ve küçük sayıyı ondan çıkarın. Küçük sayı, elementin sahip olduğu proton sayısını gösteren atom numarasıdır (z). Daha büyük sayı, elementte bulunan proton ve nötron sayısını gösterir.

  1. 41 K'nin atom kütlesi 41'dir. Atom kütlesi, elementte bulunan proton ve nötron sayısıdır. Nötron sayısını elde etmek için atom numarasını (19) atom kütlesinden (41) çıkarın. Bunu yaptığınızda K 41'in 19 protonu ve 22 nötronu olduğunu görürsünüz. Atom numarasının elementte bulunan proton sayısı olduğunu unutmayın, bu nedenle çıkarma yoluyla bulmaya çalıştığınız tek şey nötron sayısıdır.
  2. 11 Be için de aynı şey olur. Atom numarasını alın ve atom kütlesinden çıkarın. Atom kütlesi 11 ve atom numarası 4, yani 11 eksi 7'ye eşittir. B. 4 proton ve 7 nötrondur.
  3. 45 Ti için 45'ten 22 çıkarırsınız, bu da size 22 proton ve 23 nötron verir.
  4. 16 O için aynı yöntem uygulanır. 16'dan 8 çıkardığınızda 8 proton ve 8 elektron elde edersiniz.

Soru: Aşağıdaki atomlardaki proton ve nötron miktarını bulun:

  1. [_<6>^<14> extrm umara yok ]
  2. [_<8>^<18> extrm umara yok ]
  3. [_<25>^<55> extrm umara yok ]
  4. [_<30>^<64> extrm umara yok ]
  1. İlk önce, öğenin sembolünün sol tarafındaki en alttaki sayı olan alt simgeyi tanımlayın. Bu atom numarasıdır ve atom çekirdeğinin kaç proton içerdiğini gösterir. Aynı elementin tüm izotopları aynı sayıda proton içerir.
  2. Ardından, öğe sembolünün sol tarafındaki en üstteki sayı olan üst simgeyi tanımlayın. Bu atom kütle numarası, toplam proton ve nötron sayısıdır. Belirli bir elementin farklı izotopları, çekirdeklerinde bulunan nötron sayısı bakımından farklılık gösterir.
  3. Proton sayısı, basitçe atom numarası belirlenerek bulunabilir. Atomdaki nötron sayısını bulmak için atom numarası atom kütle numarasından çıkarılır.

A Karbonun atom numarası 6, oksijenin atom numarası 8, manganezin atom numarası 25 ve çinkonun atom numarası 30'dur. Bu nedenle, artık bu sayı olduğu için her atomun içerdiği proton sayısını biliyoruz. atom numarası ile temsil edilir.

B Karbon izotopunun atom kütle numarası 14, oksijen izotopunun kütle numarası 18, manganez izotopunun kütle numarası 55 ve çinko izotopunun kütle numarası 64'tür. Bu proton ve her bir ilgili izotopta nötronlar.


#3 2021-01-03 03:39:52

Ynt: 10 ve üs matematiğinde # 039m.

Günaydın Bob ve yardımın için teşekkürler.  Evet, bir hesap makinesinde üs tuşunu kullanıyorum.
Bunu nasıl yaparsam yapayım, (A) probleminin 20A'ya çözülmesi gerekiyor.  (A)'da verilen denklemi kullanarak 200A elde ediyorum.

Ders kitabı denklemi herhangi bir değişiklik yapılmadan (A)'da veriliyor.  Ben de soruyorum, formül değerlendirmemde neyi yanlış yapıyorum?   Formülün yanlış olması mümkün mü yoksa verilen cevap yanlış?


Çalışılan Örnek - Klasik Mekanik, David Morin

Problem: Bir ip bir direği θ açısıyla sarıyor. Bir ucundan tutup bir gerilimle $T_0$ çekiyorsunuz. Diğer uç büyük bir nesneye, örneğin bir tekneye bağlıdır. Halat ile direk arasındaki statik sürtünme katsayısı $mu$ ise, halat direğin etrafında kaymayacaksa, ipin tekneye uygulayabileceği en büyük kuvvet nedir?

Verilen çözüm:
$dθ$ açısına sahip küçük bir ip parçası düşünün. Bu parçadaki gerilimin $T$ olmasına izin verin (bu, küçük uzunlukta biraz değişir). Kutup, dışarıya doğru küçük bir normal kuvvet uygular, $N_$ , parça üzerinde. Bu normal kuvvet, uçlardaki gerilimlerin “içe doğru” bileşenlerini dengelemek için vardır. Bu içe doğru bileşenlerin büyüklüğü $T sin(dθ/2)$ . 1 Bu nedenle, $N_ = 2T sin(dθ/2)$ . Küçük açı yaklaşımı, $sin(x) ≈ x$, bunu $N_ olarak yazmamıza izin verir. = T dθ$ .
Küçük ip parçası üzerindeki sürtünme kuvveti $F_ değerini sağlar. ≤ μN_ = μT_$ . Bu sürtünme kuvveti, parçanın iki ucu arasındaki gerilim farkına neden olan şeydir. Başka bir deyişle, θ'nin bir fonksiyonu olarak gerilim, $T( heta+d heta)le T( heta) + mu Td heta (*) implies dT le'yi sağlar mu Td heta ima eder int frac

le int mu d heta implies ln(T) le mu heta + C implies T le T_<0>e^$

Burada anlamadığım şey, yazarın ipin diğer ucunun tekneye "bağlı" olduğunu söylemesidir. Şimdi bu, teknenin ipi biraz gerilimle "çektiği" anlamına gelmez. eğer durum buysa (halatı büyük bir gerilimle çeken tekne, $T$ deyin), o zaman ne yapılması gerektiği konusunda nettim, buna göre sürtünme kuvvetine bir yön atadık ve görmek için gereken kuvvetin olduğunu görüyoruz. ipin kaymasını önleyin, yani kitapta verilen sonuca göre $T_ <0>ge Te^<-mu heta>$ .

Ancak buradaki ip tekneye yalnızca "bağlı" olduğundan, $(*)$ ile işaretlenen denklemin nasıl doğru olduğunu anlamıyorum. "we", $T_<0>$ gerilimi ile "çekiyor" olduğundan, denklem (sürtünme yönünden dolayı..) $T( heta + d heta) + mu Td heta le T( olmamalı mı? heta) implies T le T_<0>e^<-mu heta>$

EDIT: Sorumu daha açık hale getirmek istiyorum. Bir tekneye bir ip takılır, daha sonra ip bir direğe sarılır. Şimdi ipin diğer ucunu tutup $T_<0>$ gerilimi ile çekiyorum..O zaman ipi çekme hareketime sürtünme engel olmamalı. Bu durumda $(*)$ denklemi nasıl doğru olur?

Temel olarak, yazarın $(*)$ denklemine nasıl ulaştığını bilmek istiyorum. "Parçanın iki ucu arasındaki gerilim farkına neden olan şey bu sürtünme kuvvetidir." ifadesi benim için çok net değil. "Fark" ne anlamda? $T( eta + d eta) > T( eta) metin T( eta) < T( eta + d eta)$

Yazar bunu metinde açıklamadı, bu yüzden $(*)$ denkleminin nasıl doğru olduğunu anlamıyorum. çünkü statik sürtünme kuvveti için hangi yönün seçildiğine ve nedenine dair bir açıklama yoktur.


Örnek: Bir Beyaz Gürültü İşlemi Çizimi¶

Başlamak için, $ epsilon_0, epsilon_1, ldots, epsilon_T $ beyaz gürültü sürecini simüle etmek ve çizmek istediğimizi varsayalım, burada her çizim $ epsilon_t $ bağımsız standart normaldir.

Paketlere Giriş¶

İlk adım, Project.tol ve Manifest.tol dosyaları tarafından kapsüllenen bir proje ortamını etkinleştirmektir.

Paketleri ve sürümleri kurmanın üç yolu vardır (burada ilk iki yöntem önerilmez, çünkü bunlar paket sürümlerinin notlarla uyumsuz olmasına neden olabilir)

  1. paketleri doğrudan global kurulumunuza ekleyin (örneğin, Pkg.add("MyPackage") veya ] MyPackage ekleyin)
  2. notebook ile aynı dizinde bir Project.toml ve Manifest.tol dosyası indirin (yani @__DIR__ argümanından) ve ardından Pkg Pkg.activate(@__DIR__) kullanarak arayın
  3. InstantiateFromURL paketini kullanın

Bu kodu belirli bir bilgisayarda hiç çalıştırmadıysanız, tüm bağımlı paketleri indirmesi, kurması ve derlemesi uzun zaman alabilir.

Bu kod, proje dosyalarını ders deposundan indirecek ve kuracaktır.

Bunu Araçlar ve Düzenleyiciler'de daha fazla tartışacağız, ancak bu dosyalar kod tarafından kullanılan paketlerin ve sürümlerin bir listesini sağlar.

Bu, kod çalıştırmak için bir ortamın tekrarlanabilir, böylece herkes yapımda kullanılan kesin paket ve sürüm setini çoğaltabilir.

Paket sürümlerinin dikkatli seçimi, tekrarlanabilirlik için çok önemlidir, aksi takdirde kodunuz, paketlerde kontrolünüz dışında yapılan değişiklikler nedeniyle bozulabilir.

Kurulum ve aktivasyondan sonra kullanmak, belirli bir kodun veya not defterinin paketi kullanacağını söylemenin bir yolunu sağlar.

Bir Paketteki İşlevleri Kullanma¶

Herhangi bir parametre verilmezse ortalama 0 ve varyans 1 ile normal bir dağılımdan tek bir çekiliş döndüren randn gibi bazı işlevler temel Julia'nın içine yerleştirilmiştir.

Diğer işlevler, tüm adların harici bir kitaplıktan içe aktarılmasını gerektirir.

Bunu parçalayalım ve nasıl çalıştığını görelim.

Plots kullanan ifadenin etkisi, Plots modülü tarafından dışa aktarılan tüm isimleri kullanılabilir hale getirmektir.

Pkg.activate'i daha önce kullandığımız için, Project.toml ve Manifest.toml dosyalarında belirtilen Plots.jl sürümünü kullanacaktır.

Diğer LinearAlgebra ve İstatistik paketleri, Julia kitaplıklarının temelidir, ancak açık bir kullanım gerektirir.

Çizilecek argümanlar 1,2, . x ekseni için n, y ekseni için bir vektör ϵ ve (isteğe bağlı) ayarlar.

Randn(n) işlevi, ortalama 0 ve varyans 1 olan normal bir dağılımdan rastgele çizilen bir sütun vektörü n döndürür.

Diziler¶

Matematiksel ve bilimsel hesaplamaya yönelik bir dil olarak Julia, unicode karakterleri kullanmak için güçlü bir desteğe sahiptir.

Yukarıdaki durumda, ϵ ve diğer birçok sembol, LaTeX ve <TAB>, yani epsilon<TAB> sağlayarak çoğu Julia düzenleyicisinde yazılabilir.

Dönüş türü, en temel Julia veri türlerinden biridir: bir dizi

typeof()'tan gelen bilgi bize ϵ'nin 1 boyutunda 64 bitlik kayan noktalı değerlerden oluşan bir dizi olduğunu söyler.

Julia'da, tek boyutlu diziler, lineer cebir amaçları için sütun vektörleri olarak yorumlanır.

ϵ[1:5], ϵ öğesinin ilk 5 öğesinin bir dizisini döndürür.

Yukarıdakilerden dikkat edin

  • dizi indeksleri 1'den başlar (MATLAB ve Fortran gibi, ancak Python ve C'den farklı olarak)
  • dizi öğelerine köşeli parantezler kullanılarak başvurulur (MATLAB ve Fortran'ın aksine)

Almak yardım ve örnekler Jupyter veya diğer julia düzenleyicide, ? bir işlev adından veya sözdiziminden önce.

Döngüler için'182

Programımızla ne elde etmek istediğimize dair bir ihtiyaç olmasa da, sözdizimini öğrenmek adına, verileri oluşturmak için bir for döngüsü kullanacak şekilde programımızı yeniden yazalım.

Not

Julia v0.7 ve sonraki sürümlerde, for ve while döngülerinde erişilen değişkenler için kurallar, bunların nasıl kullanıldığına duyarlı olabilir (ve değişkenler bazen bildirimin bir parçası olarak global gerektirebilir). Jupyter dizüstü bilgisayarların dışındaki for ve while döngülerinden en üst düzeyden (yani REPL'de veya işlevlerin dışında) kaçınmanızı şiddetle tavsiye ederiz. Bu sorun, işlevler içinde kullanıldığında geçerli değildir.

En doğrudan sürümle başlayarak ve randn'nin yalnızca tek bir değer döndürebildiği bir dünyadaymışız gibi davranarak

Burada ilk önce ϵ öğesini 0.0 kayan nokta ile başlatılan n sayıdan oluşan bir vektör olarak tanımladık.

for döngüsü daha sonra bu diziyi randn() öğesine yapılan ardışık çağrılarla doldurur.

Julia'daki tüm kod blokları gibi, for döngüsü kod bloğunun sonu (burada yalnızca bir satırdır) end anahtar sözcüğüyle belirtilir.

for döngüsündeki kelime ∈ veya = ile değiştirilebilir.

İndeks değişkeni 1:n'den itibaren tüm tamsayılar için döngüye alınır – ancak bu aslında bu indekslerin bir vektörünü oluşturmaz.

Bunun yerine, bir yineleyici bu döngüye alınır - bu durumda Aralık 1'den n'ye kadar tamsayılar.

Bu örnek ϵ'yi doğru değerlerle başarıyla doldururken, i indeksi ile ϵ vektörü arasındaki bağlantı belirsiz olduğu için çok dolaylıdır.

Bunu düzeltmek için her dizini kullanın

Burada, eachindex(ϵ), ϵ öğesine erişmek için kullanılabilecek bir dizin yineleyicisi döndürür.

Öğeler bellekte saklanmak yerine anında oluşturulduğu için yineleyiciler bellek açısından verimli olsa da, ana yararı (1) daha net ve yazım hatalarına daha az eğilimli kodlara yol açabilmesi ve (2) derleyici esnekliğinin yaratıcı bir şekilde çalışmasına izin vermesidir. hızlı kod oluşturun.

Julia'da doğrudan dizilerin üzerinde de döngü yapabilirsiniz, bunun gibi

burada ϵ[1:m], vektörün öğelerini 1 ila m arasındaki indekslerde döndürür.

Tabii ki, Julia'da bu hesaplamayı gerçekleştirmek için karşılaştırabileceğimiz yerleşik işlevler vardır.

Bu örneklerde, tamsayılar ve diğer türler için uygun olan == yerine eşitliği test etmek için ≈ kullanımına dikkat edin.

about<TAB> ile yazılan yaklaşık olarak eşittir, kayan nokta matematiğinin standart sorunları nedeniyle herhangi bir kayan noktalı sayıları karşılaştırmanın uygun yoludur.

Kullanıcı Tanımlı İşlevler¶

Alıştırma uğruna, for döngüsüne geri dönelim, ancak programımızı, kullanıcı tanımlı bir fonksiyon içinde rastgele değişkenler oluşturulacak şekilde yeniden yapılandıralım.

İşleri daha ilginç hale getirmek için, çekilişleri dağıtımdan doğrudan çizmek yerine, bu çekilişlerin karelerini çizelim.

  • function, bir işlev tanımının başlangıcını belirten bir Julia anahtar sözcüğüdür.
  • createata, işlev için isteğe bağlı bir addır
  • dönüş, genellikle gereksiz olduğu için dönüş değerini gösteren bir anahtar kelimedir

Randn'nin bir vektör döndürebileceğini "hatırlayarak" bu örneği biraz daha iyi hale getirelim.

Daha iyi olsa da, sonuçların karesini almak için i indeksi üzerindeki döngüyü okumak zordur.

Döngü yapmak yerine, yapabiliriz yayın yapmak kullanarak bir vektör üzerinde ^2 kare işlevi. .

Açık olmak gerekirse, Python, R ve MATLAB'ın (daha az ölçüde) aksine, for'u bırakmanın nedeni şudur: olumsuzluk performans nedenleriyle değil, kod netliği nedeniyle.

Bu tür döngüler, Julia gibi derlenmiş dillerde en az vektörleştirilmiş yaklaşım kadar etkilidir, bu nedenle kodu daha net hale getirdiğini düşünüyorsanız bir for döngüsü kullanın.

Hatta tek satırda tanımlarsak fonksiyonu bırakabiliriz.

Son olarak, kare almanın yalnızca özel bir durum olduğu herhangi bir işlevi yayınlayabiliriz.

Nihai – soyut – bir yaklaşım olarak, createata fonksiyonunun bir fonksiyona genel olarak uygulanabilmesini sağlayabiliriz.

Bu örneğin önceki sürümden daha iyi veya daha kötü olup olmadığı, nasıl kullanıldığına bağlıdır.

Yüksek derecede soyutlama ve genellik, ör. bu durumda bir f fonksiyonundan geçmek, kodu daha net veya daha kafa karıştırıcı hale getirebilir, ancak Julia bu teknikleri kullanmanızı sağlar. performans yükü olmadan.

Bu özel durum için en açık ve en genel çözüm muhtemelen en basit olanıdır.

Yukarıda yayın yapmak yüzeysel olarak MATLAB veya Python ufuncs'taki vektörleştirme işlevleri gibi görünse de, çok daha zengindir ve dilin temel temelleri üzerine kuruludur.

Diğer ek fonksiyon arsa! mevcut çizime bir grafik ekler.

Bu, Julia'da, argümanları veya global bir durumu değiştiren bir fonksiyonun bir ! adının sonunda.

Biraz Daha Kullanışlı Bir İşlev¶

Biraz daha kullanışlı bir fonksiyon yapalım.

Bu işlev, bir olasılık dağılımı seçiminde geçirilecek ve bir gözlem histogramı çizerek yanıt verecektir.

Bunu yaparken, yukarıda proje ile somutlaştırıldığını varsaydığımız Dağıtımlar paketini kullanacağız.

Teknik ayrıntıları derslerin ilerisine bırakırken, tüm bunların nasıl çalıştığına dair gündelik bir tartışma yapalım.

İlk olarak, lp = Laplace(), Laplace dağıtımını temsil eden Dağıtımlar modülünde tanımlanan bir veri türünün örneğini oluşturur.

lp adı bu değere bağlıdır.

plothistogram(lp, 500) fonksiyon çağrısını yaptığımızda, plothistogram fonksiyonunun gövdesindeki kod şu şekilde çalıştırılır:

  • lp ile aynı değere bağlı isim dağılımı
  • n adı 500 tamsayısına bağlı

Bir Gizem¶

Şimdi rand(distribution, n) işlev çağrısını düşünün.

Bu gizemli bir şeye benziyor.

Rand() işlevi, temel kitaplıkta, rand(n) $ [0, 1) $ üzerinde n tane tek tip rasgele değişken döndürecek şekilde tanımlanır.

Öte yandan, dağıtım, üçüncü taraf bir pakette tanımlanan Laplace dağıtımını temsil eden bir veri türüne işaret eder.

Peki nasıl oluyor da Rand() bu tür bir değeri argüman olarak alıp istediğimiz çıktıyı döndürebiliyor?

Cevap kısaca şudur çoklu gönderimJulia'nın uygulamak için kullandığı genel programlama.

Bu, Julia'daki işlevlerin, geçtikleri belirli argümanlara bağlı olarak farklı davranışlara sahip olabileceği fikrine atıfta bulunur.

Bu nedenle Julia'da mevcut bir işlevi alabilir ve yeni bir değer türü üzerinde nasıl hareket ettiğini tanımlayarak ona yeni bir davranış verebiliriz.

Derleyici, işlevin çağrıldığı değerlerin türlerine bakarak belirli bir ayarda hangi işlev tanımına uygulanacağını bilir.

Julia'da bir fonksiyonun bu alternatif versiyonları denir. yöntemler.


LAB #4: Hızlı ve Tehlikeli Kök Bulma

İkiye bölme yöntemi çok güvenilirdir, ancak yavaş ve sıkıcıdır. Özellikle doğru köke yakın olduğunda daha hızlı olan birçok klasik yöntem vardır. Bu yöntemlerin çoğu, bir kökün kendisi kadar bulunması neredeyse zor olabilen bir işaret aralığı değişikliği gerektirmez. Ancak, akılsızca kullanılırsa, bu hızlı yöntemler muhteşem bir şekilde çökebilir ve ikiye bölmeyi güvenli bir şekilde sürükleyebilir. Bu laboratuvarda, Brent yöntemi olarak bilinen hız ve güvenliği birleştirmeye çalışan modern bir yöntemle bitirerek kökleri bulmanın daha hızlı birkaç yolunu inceleyeceğiz. Ne yazık ki, bu yöntemlerin nasıl başarısız olabileceğini araştırmak için zamanımız olmayacak.

Bu laboratuvarı tamamlamak için iki oturum alacağız.

Testleri Durdurma

Kök bulma rutinleri, mevcut sonucun yeterince iyi olup olmadığını görmek için her adımdan sonra kontrol eder. Yapılan testlere sonlandırma koşulları veya durdurma testleri denir. Yaygın testler şunları içerir:

Artık boyut : | F(X) | < tolerans

Aralık boyutu : | X(sağ) - X(sol) | < tolerans

Artış boyutu : | X(yeni) - X(eski) | < tolerans

Maksimum yineleme : IT < ITMAX

Bazı yöntemler her zaman bir işaret aralığı değişikliğine sahiptir [X(sol),X(sağ)], bu nedenle aralık boyutu testi kullanılabilir. Diğer yöntemler yoktur ve bu nedenle her adımda kök tahminindeki değişikliğin boyutuna odaklanırız.

İkiye bölme yöntemi için en doğal test, işaret değiştirme aralığının boyutu üzerindedir. Ancak diğer yöntemlerle karşılaştırma yapabilmek için hepsi için artık boyut durdurma testi kullanmak isteyeceğiz. Bu yüzden bugün için ikiye bölme kodunu yeniden tasarlamamız gerekiyor. Hepimizin aynı dosyayla çalışabilmesi için bisect.m dosyamın bir kopyasını indirin. Lütfen a, b ve c değişken adlarını xa, xb ve xc olarak değiştirdiğimi unutmayın. Bunu, bunların f fonksiyonu için değil, bağımsız değişken x için değerler olduğunu vurgulamak için yaptım.

Alıştırma : İkiye bölme kodunu değiştirin. İlk olarak, sözde sihirli sayılara tanımlayıcı adlar vermek iyi bir programlama uygulamasıdır, bu nedenle mutlak durma toleransına FATOL (Fonksiyon Mutlak TOLERANSI) diyelim. Değerleri asla değişmeyen değişkenleri adlandırmak için tüm büyük harfleri kullanmak gelenekseldir. Ardından, ITMAX olarak dayanmaya hazır olduğumuz maksimum yineleme sayısını tanımlayın. Bu şekilde asla sonsuz bir döngüye girmeyeceğiz, ancak çok az yinelemenin sonucu olan bir değeri yakınsanmış olarak kabul etmemeye dikkat etmeliyiz. Bir yineleme sayacı it_count tanımlayın ve bunu while ifadesini değiştirmek için kullanın.

Ardından, döngüyü sonlandıran end ifadesinden hemen önce, kalan boyuta şu durdurma koşullarını ekleyin:

(Dikkatli bir programcı, döngü, durdurma koşulu karşılandığı için değil de, it_count son değerine ulaştığı için sona ererse, bir uyarı yazdıracaktır.) İşlev üzerinde yeni ikiye bölme kodunuzu kullanın.

0 ve 5 başlangıç ​​noktaları ile ve sonucun FATOL'den küçük veya eşit bir fonksiyon değerine sahip olduğunu doğrulayın. Bu kaç adım sürer?

Regula Falsi

Regula Falsi, ikiye bölme yöntemine çok benzer: bir işaret aralığı değişikliği ile başladığımızı varsayar ve yöntemin her adımı bu aralığı küçültmeye çalışır. Bununla birlikte, ikiye bölmenin uç noktaların ortalamasını aldığı yerde:

Regula Falsi yöntemi, ağırlık olarak uç noktalarda işlevin boyutunu kullanır:

İki uç noktadaki fonksiyon değerleri eşit büyüklükte ve zıt büyüklükte ise, bu ikiye bölme ile aynı sonucu alır. Ancak f(xb)'nin çok negatif ve f(xa)'nın biraz pozitif olduğunu varsayalım. Kökün xa'ya yakın olmasını beklemez miydiniz? Regula Falsi'nin onu arayacağı yer orası.

Regula Falsi hakkında not edilmesi gereken bir şey, fonksiyonun enterpolasyonlu bir modeline dayanmasıdır. Başka bir deyişle, algoritma, bilinmeyen fonksiyonun bilinen iki değerini "kanıt" olarak alır ve bundan bütün bir çalışan model fonksiyonu oluşturur. Model işlevi çok basittir, yalnızca iki veri noktasından geçen doğrusal işlev. Ancak incelediğiniz nesnenin "bir modelini oluşturma" fikri çok önemlidir. Örneğin Regula Falsi, bize fonksiyonun türevinin veya integralinin veya keyfi bir noktadaki değerinin bir tahminini de verebilir. Bize yeni bir veri parçasının ne zaman "şaşırtıcı" olduğunu ya da pratikte beklenenin ne olduğunu söyleyebilirdi, bunların hiçbiri ikiye bölmeyi yapamazdı. Bu fikri kök bulmada ve incelediğimiz diğer konularda tekrar tekrar göreceğiz.

Alıştırma : Az önce yazdığınız ikiye bölme programının bir kopyasını alın ve regula.m olarak adlandırın. Dikkatlice inceleyin ve ikiye bölmeden Regula Falsi'ye nasıl değiştireceğinizi görün. Bu değişiklik, yukarıdaki (b) uygulaması satırının yukarıdaki (r) uygulamasıyla değiştirilmesi anlamına gelir. Dosyada f(xb)'nin fb olarak adlandırıldığını unutmayın. 0 ve 5 başlangıç ​​noktalarıyla f1(x) işlevinde kodunuzu deneyin. Bu kaç adım alır? Aralığın bir tarafının neden hiç değişmediğini açıklamaya çalışın.

Sekant Yöntemi

Regula Falsi, bazı problemler için ikiye bölmeden daha iyidir. Ancak, onu yenmek kolaydır. Doğrusal fonksiyonlarda iyi olsa da, ikinci türevinin önemli olduğu bir fonksiyonu işleyemez. Bir uç noktanın çok büyük bir fonksiyon değerine sahip olması, yöntemi diğer uç noktaya yakın bakmaya zorlar. Bu, problem diğer uçtayken, yöntemin çıkmaza girdiği ve aralığın "küçük" tarafını çok yavaş hareket ettirdiği anlamına gelebilir.

Sekant yöntemi, her zaman bir işaret aralığı değişikliği tutma fikrini bırakır. Bunun yerine, yeni bir nokta hesaplarken, her zaman orijinal nokta çiftinin en eskisini atar. Artık bir işaret aralığı değişikliğimiz olmadığı gerçeğini yansıtmak için, sekant algoritması nokta çifti için x1 ve x2 adlarını kullanacaktır.

Sekant yöntemi, fonksiyonun doğrusal bir modelini kullanma fikrini korur. Bu, yineleme adımının Regula Falsi yöntemindekiyle aynı olduğu anlamına gelir.

Böylece, sekant algoritmasının her adımı x1 ve x2 noktalarıyla başlar ve xnew değerini hesaplar. Sekant algoritması bir sonraki adıma hazır olabilmek için adım sonunda şunları yapar:

Sekant yönteminin hızlandırılmasının bir açıklaması, eski verileri atmasıdır. Bu nedenle, eğer yöntem yakınsıyorsa, sürekli olarak en iyi verileri kullanıyor ve dolayısıyla hızlanıyor. Tersine, yöntem kötüye gitmeye başlarsa, onu gerçeğe geri getirebilecek bilgiyi çok çabuk unutur ve sonsuza uçar!

Alıştırma : Regula Falsi programınızın bir kopyasını yapın ve ona secant.m adını verin. Değişkenleri yeniden adlandırın ve kodu secant yöntemini kullanacak şekilde değiştirin. Değişkenleri yeniden adlandırmak, şimdi sorun yaşarsanız veya bu dosyalara daha sonra bakmak isterseniz, karışıklığı önlediği için önemlidir. 0 ve 5 başlangıç ​​noktalarıyla f1(x) işlevinde kodunuzu deneyin. Bu kaç adım alır?

Newton'un Yöntemi

Hem Regula Falsi hem de sekant yöntemi, esasen fonksiyonun eğimini ve dolayısıyla ekseni nereden geçeceğini bulmak için bir çift nokta kullanır. Diyelim ki süreç birleşiyor. Yakınsaksak, en son yineleme köke en yakın olanıdır ve bu nedenle eğimin en iyi tahmini mevcut noktadaki türevdir. Newton'un yöntemi, bilinmeyen fonksiyonun (doğrusal) bir modelini kullanıyor, ancak "kanıtları" artık en son noktada toplanıyor.

(Newton'un yöntemi, sekant yönteminden bile daha hızlıdır, buna "kötü gidebilmesi" veya daha hızlı sapabilmesi de dahildir!)

Newton'un yöntemi için yineleme adımı:

Eski bilgileri kaydetmiyoruz, bu yüzden yeni noktayı xnew olarak adlandırma zahmetine girmedim. Yalnızca hemen önceki x değerini değiştirir.

Bu arada, fonksiyona Newton'un yöntemini uygularsak

yineleme adımımız

Bu formül tanıdık geliyor mu?

Ne yazık ki Newton yönteminin biçimi MATLAB kodlamamızı karmaşıklaştırıyor, çünkü şimdi fonksiyon ve türevi için iki rutin yazmamız gerekiyor. (Elbette bunu yapmanın başka yolları da var!) Ancak bu, fonksiyonumuzun ilk satırının muhtemelen şöyle görüneceği anlamına gelir:

burada df, f fonksiyonunun türevini hesaplamak zorunda olan başka bir M dosyasının adıdır.

Alıştırma : secant programınızın bir kopyasını yapın ve onu newton.m olarak adlandırın. İşlev ifadenizi yukarıda açıklandığı gibi değiştirin. Şimdi sadece bir x değişkenine ihtiyacınız olacak. UYARI: sadece bir x değişkeni ile, yakınsama kriteri dahil olmak üzere birkaç kod satırını değiştirmeniz gerekecektir. İşlevi değerlendirirken şimdi iki arama yapmanız gerekecek:

Ardından yeni yineleme adımını ekleyin:

Kodunuzu f1(x) fonksiyonu üzerinde başlangıç ​​noktası 1 ile deneyin. (f1(x) için bir türev yordamı yazmalısınız. Buna df1.m deyin). Bu kaç adım sürer?

Muller'ın Yöntemi

Muller'in yöntemi en iyi, bilinmeyen fonksiyonu "modellemek" için başka bir girişim olarak anlaşılır. Yöntemin her adımında üç nokta kullanılır. Muller'in yöntemi, bu üç noktadan geçen ikinci dereceden polinomu belirler ve daha sonra o polinomun köklerini çözer ve en eski noktayı atarken bunlardan birini en son noktası olarak eklemek için seçer.

Muller'ın yöntemi hızlı olabilir, ancak yanlış gidebilecek birkaç şey var. Veri noktaları çok yakınsa veya düz bir çizgi üzerindeyse, ikinci dereceden katsayıların hesaplanmasında doğruluk sorunları ve köklerini belirlemede daha fazla sorun vardır. Ayrıca, Muller'ın yönteminin kodlaması, gördüğümüz diğer yöntemlerden önemli ölçüde daha karmaşıktır.

Muller'in yönteminin tuhaf bir özelliği, ikinci dereceden polinomun gerçek köklerinin olmamasıdır. Ancak bu durumda, karmaşık köklerden birinin peşine düşmek tamamen kabul edilebilir olabilir ve yöntemin bunu yapmasına izin verirseniz, aynı şekilde çalışır. Size verdiğim algoritmaya bakarsanız, karmaşık köklü bir problem üzerinde çalışması için sadece bir satırı silmeniz yeterlidir.

Alıştırma: Muller'ın yönteminin benim versiyonumun bir kopyasını alın. Kodunuzu f1(x) işlevinde 0, 5 ve 10 üç başlangıç ​​noktasıyla deneyin. Bu kaç adım alır? AÇIKLAMAK!

Alıştırma : Muller'in yönteminin en az üç yineleme aldığı bir fonksiyon ve bir başlangıç ​​üçlüsü oluşturun.

Ekstra alıştırma : Eğer ilgileniyorsanız, karmaşık köklerin aranabilmesi için hangi algoritma satırının silinmesi gerektiğini bulun. Ardından kodunuzu deneyin

Brent'in Yöntemi

Richard Brent, ikiye bölmenin güvenilirliğini sekant yönteminin hızıyla birleştiren bir rutin geliştirdi ve daha hızlı olabilecek başka bir yöntem ekledi. Buradaki fikir, bir işaret aralığı değişikliği ile başlamanız ve onu asla bırakmamanızdır. Bir sonraki adımınız için üç seçeneğiniz var:

"ters ikinci dereceden" adım (hızlı)

Yineleme oldukça iyi ilerliyorsa, sizi mevcut işaret aralığı değişikliğinin dışına çıkarmayacak olan "en hızlı" adımı atın. Ancak, sekant veya ters ikinci dereceden adımlar deniyorsanız ve yine de aralık çok küçülmediyse, ikiye bölme adımına geri dönün.

Tahmin edebileceğiniz gibi, bu algoritmanın yazılması oldukça karmaşıktır. Ancak, açıkça daha fazla zeka gösterir. Çeşitli yöntemler kullanır ve mevcut sorunla ilgili deneyimine dayanarak yaptıklarını ayarlamaya çalışır. Böyle bir yönteme uyarlamalı denir. Ayrıca, her zaman bir cevap alacak şekilde (çünkü işaret aralığı değişimini asla bırakmaz ve sık sık bir ikiye bölme adımını zorlar) dikkatlice dengelenir ve cevabı hızlı bir şekilde almaya çalışır.

Alıştırma: Brent yönteminin benim versiyonumun bir kopyasını alın. 0 ve 5 başlangıç ​​noktalarıyla f1(x) işlevinde kodunuzu deneyin. Bu kaç adım alır?

Egzersiz yapmak

Newton yönteminin bir dezavantajı, sadece fonksiyonu değil, aynı zamanda bir türevi de sağlamamız gerektiğidir. Bu alıştırmada, hayatı biraz daha kolaylaştırmaya çalışacağız.

Buradaki fikir, fonksiyonun türevine yaklaşmak istediğimizdir. Bunun bir yolu, yakındaki bir noktayı dikkate almak olacaktır.

oradaki fonksiyonu değerlendirin ve ardından türevi şu şekilde tahmin edin:

Here are three ways to pick the stepsize dx :

Simply set xp to the previous iterate. (On the first step, set xp to x+1.0 )

Always use a fixed value, say dx = 0.001

Use a value that gets smaller as you converge, say dx = fx .

We will try idea #2, using a fixed stepsize.

Make a copy of your Newton code, called newton1.m, whose declaration looks like

by the appropriate lines to approximate the derivative using a stepsize dx = 0.001 . Check out your code on the function f1(x)=x^2-9 .

For the function f2(x)=x^6-x-1 and the starting point x = 5.0 and the absolute function tolerance of 0.000001, compute the number of steps taken to converge to the root x=1.134. using the standard method, and four stepsizes dx :


FPU on F407 – how to

7 digits with basic math primitives and typical algorithms. With transcendental math functions do expect 5-6 digits.

The Single Precision theoretical scope is from +/- 1.175494351E-38 .. 3.402823466E+38.
Not all real numbers have their Single Precision representation, though.

The FPU provides only a few basic primitive functions (like add, sub, mul, div, sqrt) and several other supporting functions. It does not provide you with results like sinf(), still the sw math libraries must be used for transcendental functions. With stm32duino the gcc build-in libraries will be used (when proper compile flags are used). You may also use CMSIS DSP library instead.
[attachment=1]STM32F407 FPU INSTR.JPG[/attachment] The Single Precision is good for:
1. audio, video, sensors processing, control and regulation – everywhere you need speed, large dynamics, but lower resolution is acceptable
2. for DSP with 12-18bit ADC values, FFT, IFFT, FIR IIR filters, SI conversions
3. math with and printing out real values with larger order ranges (pico, nano. mega, giga) but with 6-7 digits
4. math calcs where the algorithm can accept the lower resolution.

The Single Precision is NOT good for:
1. navigation, gps, cartography, land surveying
2. measuring and calcs with frequencies (DDS, frequency measurements, etc.)
3. numerical calculation in science and technology – in mathematics, physics, astronomy, etc.
4. pocket calculators
5. CAD systems and simulators
6. financial calculation.

HINT: I recommend this reading https://ece.uwaterloo.ca/

dwharder/Nume … /paper.pdf
as the using of floating point math could be sometimes tricky..

In your platform.txt add
-mfloat-abi=hard -mfpu=fpv4-sp-d16 -fsingle-precision-constant

it would seem that hardware float would need to be handled as somewhat a ‘library’ approach. i’d think the missing CMSIS libmath.a libraries probably is a reason causing my sketch to ‘hang’. the surprising thing would be that with gcc 6 i didn’t seem to hit compile or link errors that functions are missing


1 Cevap 1

The answer can be worked out by reading the documentation.

Return True if the values a and b are close to each other and False otherwise.

Whether or not two values are considered close is determined according to given absolute and relative tolerances.

rel_tol is the relative tolerance – it is the maximum allowed difference between a and b, relative to the larger absolute value of a or b. For example, to set a tolerance of 5%, pass rel_tol=0.05. The default tolerance is 1e-09, which assures that the two values are the same within about 9 decimal digits. rel_tol must be greater than zero.

abs_tol is the minimum absolute tolerance – useful for comparisons near zero. abs_tol must be at least zero.

If no errors occur, the result will be:

You use default tolerances which means that a relative tolerance check is used. And the equation above makes it clear why your expressions evaluates false.

Consider the final expression in the question:

Plug these values into the expression from the documentation and we have

I think it should be obvious that when performing a relative tolerance comparison, using default tolerances, no non-zero value is deemed close to zero.


Videoyu izle: Video Promocional do Curso Online EAD: KARATE KUMITE. Andre Maraschin (Ekim 2021).