itthon / Avatar / A következő elem kiszámítása az előzőek felhasználásával a Matlabban. Egyszerű számítások MATLAB-ban. ODE Solvers használata

A következő elem kiszámítása az előzőek felhasználásával a Matlabban. Egyszerű számítások MATLAB-ban. ODE Solvers használata

Számítások és adatok közelítése MATLAB-ban

Lineáris algebrai egyenletrendszerek és spektrális feladatok megoldása

A lineáris algebrai egyenletrendszerek megoldása az egyik fő számítási probléma, hiszen a legkülönfélébb alkalmazási területeken felmerülő problémák nagy száma redukálódik rá. A mechanikai feladatok közelítő megoldására alkalmazott numerikus módszerek, folyadékok és gázok áramlásának számítására, egyéb, folytonos közegben zajló fizikai folyamatok, elektromos áramkörök számítási módszerei, adatok közelítésének módszerei vezetnek lineáris algebrai egyenletrendszerek megoldásának szükségességéhez (és ez nem a lineáris algebrai rendszerek előfordulási forrásainak teljes listája). Spektrális problémák merülnek fel például a szerkezetek frekvenciaelemzésénél, az elektromos áramkörökben és vezérlőrendszerekben zajló folyamatok stabilitásának vizsgálatánál és sok más alkalmazási területen.

A MATLAB lineáris algebrai egyenletrendszerek megoldására vonatkozó képességeinek áttekintése

A MATLAB környezetet eredetileg mátrixokkal való munkára fejlesztették ki (a MATLAB a Matrix Laboratory rövidítése), így a lineáris algebrai egyenletrendszerek megoldására szolgáló MATLAB eszközök arzenálja meglehetősen gazdag, és a következőket tartalmazza:

  • négyzet- és téglalap alakú mátrixú rendszerek megoldása;
  • rendszerek megoldása direkt és iteratív (beleértve az előkondicionálás lehetőségét is) módszerekkel;
  • mátrixbontások;
  • nagy ritka mátrixok tárolása kompakt formában és speciális algoritmusok az ilyen mátrixokkal rendelkező rendszerek megoldására.

Rendszerek megoldása fordított perjelekkel

A rendszerek megoldásának legegyszerűbb módja a fordított perjel használata. Tegyük fel, hogy meg kell oldanunk a rendszert

Ehhez töltse ki a mátrixot és az oszlopvektort a jobb oldalon (a jobb oldalnak egy oszlopnak kell lennie, különben hiba jelenik meg a méretbeli eltérésről)

és használja a fordított perjelet

X = A\f x = 1 1 1

A fordított perjel helyett meghívhatja az mldivide függvényt

X = mlosztás(A, f)

Az eredmény ugyanaz lesz

Az eltérés kiszámításával meggyőződünk arról, hogy a megoldást helyesen találtuk meg (általában az eltérési összetevők kis értékei nem mindig jelzik a helyesen megtalált megoldást)

F - A*x ans = 0 0 0

Nagyon fontos, hogy ne keverjük össze A-t és f-et, mert művelet végrehajtása során

nem lesz hiba, de megjelenik

X = 0,2707 0,3439 0,3854

aminek semmi köze a vizsgált rendszer megoldásához. Nézzük meg, miért történik ez úgy, hogy írunk egy rendszert egy f „mátrixszal” és egy „jobb oldali” A-val. Ebben az esetben csak egy ismeretlen lesz, mert f méret 3x1:

Ha van mátrix a jobb oldalon, akkor annyi rendszer lesz megoldva, ahány oszlopa van a mátrixnak, és minden oszlop a megfelelő rendszer jobb oldalának vektora (azaz a backslash operátor több megoldást is lehetővé tesz rendszerek egyszerre). Tehát a rendszerek meg vannak oldva

Szigorúan véve ezeknek a rendszereknek nincs megoldása. Ha azonban a rendszer mátrixa téglalap alakú és sorainak száma nagyobb, mint az oszlopok száma (vagyis az egyenletek száma nagyobb, mint az ismeretlenek száma), akkor egy ilyen rendszert túldefiniált rendszereknek nevezünk, és ennek közelítő értéke. a megoldást a maradék euklideszi normájának minimalizálásával keresik. Tehát az első rendszerre a megoldás lesz x, amely minimumot ad a következő kifejezéshez

(4-7x 1) 2 + (3-11x 1) 2 + (2-12x 1) 2

Könnyű megbizonyosodni arról, hogy a minimum csak . Használjuk például a Symbolic Math Toolboxot

Syms x R = (7*x-4)^2 + (11*x-3)^2 + (12*x-2)^2 dRdx = diff(R) x = megold(dRdx) x = 85/314 double(x) ans = 0,2707

Tehát az x = f\A felírásával kapott vektor három túldefiniált rendszer megoldását tartalmazza, amelyek mindegyikének jobb oldala az A mátrix megfelelő oszlopa.

Természetesen a felülírt rendszer mátrixa nem feltétlenül csak egy oszlopot tartalmaz. Példaként tekintsük a paraméterválasztási problémát aÉs b lineáris modell megadott táblázatos adatok szerint

k 1 2 3 4 5
x k 1.0 1.5 2.0 2.5 3.0
y k 2.99 2.81 2.89 3.03 3.21

Ez a probléma túldefiniált rendszerré redukálódik a tekintetében aÉs b, ha egyenlőséget követelünk y(x k)=y k Mert k=1,2,...,5:

Összeállítjuk a rendszermátrixot és a jobb oldal vektorát

X = (1:0,5:3)" A = ; f = ; és oldja meg c = A\f kapunk c = 2,9903 2,0100 azaz az adatok és közelítések grafikonja megerősíti a kapott eredmények helyességét ábra fun = @(x ) c(1)/x + c(2)*log(x); fplot(fun, ) hold on plot(x, y, "or")

Ha egy rendszerben több egyenlet van, mint ismeretlen, akkor az ilyen rendszert aluldefiniált rendszernek nevezzük, és a MATLAB-ban a fordított perjel segítségével megoldható. Végtelen sok megoldása lesz, és olyan megoldást találunk, amely a lehető legtöbb nulla értéket tartalmazza. Tekintsük ezt a példát

A = ; f = ; x = A\f x = 1,3333 1,0000 0 1,6667

A fordított perjelen kívül normál perjel karakter is használatos. Ezeket a következő szabály köti össze

B/A egyenértékű (A"\B")"
ahol az aposztróf transzponálást jelent. A normál perjel helyett használhatja az mrdivide függvényt is.

Egyelőre nem foglalkozunk a backslash műveletbe ágyazott rendszerek megoldási algoritmusaival. Ez a rész ennek szentelt. Az LU dekompozíciót különösen általános négyzetmátrixú rendszerek megoldására használják. Ezenkívül ellenőrzik a mátrix feltételrendszerét. A rosszul kondicionált mátrix klasszikus példája a Hilbert-mátrix, amelynek elemeit a képlet határozza meg. Adott méretű Hilbert-mátrix létrehozásához MATLAB-ban használja a hilb függvényt. Oldjunk meg például egy 13. rendű rendszert, aminek a jobb oldala olyan, hogy megoldása minden egység ( k A jobb oldal edik eleme az elemek összege k-a mátrix sora). A = hegy (13); f = összeg(A, 2); x = A\f

Ennek eredményeként üzenetet kapunk a rossz kondicionálásról

Figyelmeztetés: A mátrix közel áll az egyes számhoz, vagy rosszul skálázott. Az eredmények pontatlanok lehetnek. RCOND = 2.339949e-018.

(Az RCOND a feltételszám inverzének becslése) és egy helytelen megoldás

X = 1,0000 1,0000 1,0004 0,9929 1,0636 0,6552 2,2023 -1,7860 5,3352 -3,4773 3,9431 -0,1145 1,1851

A mátrix rossz kondicionálásából adódó veszélyeket a fejezet ismerteti. Most áttekintjük a MATLAB-ban elérhető mátrixbontásokat.

Cholesky, LU és QR mátrix dekompozíciók

A MATLAB a következő bővítményekhez rendelkezik funkciókkal:

  • Cholesky-kiterjesztés - funkció chol;
  • LU bővítés - lu függvény;
  • QR dekompozíciók - qr függvény.

A bővítések segítenek hatékonyan megoldani egy sor lineáris algebrai egyenletrendszert ugyanazzal a mátrixszal és több jobb oldali vektorral. Vegye figyelembe a következő rendszerkészletet:

Ax=f(k), k=1, 2,...,N.

Tegyük fel, hogy a mátrix A két mátrix és mátrixokkal rendelkező rendszerek szorzataként jelenik meg A=BCés mátrixokkal rendelkező rendszerek BÉs C sokkal gyorsabban megoldható, mint egy mátrixszal A. Ezután a következőképpen kapjuk meg az eredeti rendszerek megoldásait. Mert a Ax=f(k)És A=BC, Azt BCx=f k)és szekvenciális megoldása by=f(k)És Cx=y megoldást találunk k rendszer. A kitöltött mátrixok esetében a bontás a következőképpen történik: O(n 3) műveletek, ahol n- a mátrix mérete (azaz a rendszer megoldásával egy időben), és a rendszer megoldása minden bővítési tényezővel O(n 2) műveletek. Ezért a megoldás N c rendszerek előzetes bővítési igényekkel O(n 3)+O(n 2)N. Az egyes rendszerek mátrixbontás nélküli megoldása szükségessé tenné O(n 3)N aritmetikai műveletek.

Cholesky-felbontás adott mátrixra A egy ilyen felső háromszögmátrix megtalálásából áll R pozitív átlós elemekkel, amelyek A=R T R. Ismeretes, hogy ha a mátrix A szimmetrikus és pozitív határozott (azaz bármely vektorra x igaz: x T Ax0, vagy ami ugyanaz, a mátrix összes sajátértéke pozitív), akkor a Cholesky-felbontás létezik és egyedi.

Példaként tekintsük a mátrix Cholesky-féle dekompozícióját

A = ; R = chol(A) R = 2,0000 0,5000 0,5000 0 1,9365 0,3873 0 0 1,8974

Egy egyszerű ellenőrzés biztosítja, hogy a bontás helyesen történjen (a valós számokkal végzett műveletek során fellépő hibák pontosságán belül)

A - R"*R ans = 1,0e-015 * 0 0 0 0 0 0 0 0 0,4441

Ha a mátrix nem pozitív határozott, akkor ez a bomlási folyamat során derül ki, mert ki kell bontani a negatív szám gyökerét, és egy megfelelő figyelmeztetés jelenik meg:

A = ; R = chol(A)??? Hiba a ==> chol A mátrixnak pozitív határozottnak kell lennie.

A chol függvény nem ellenőrzi a mátrix szimmetriáját. A számítások az eredeti mátrix elemeit használják, amelyek az átlón és felette helyezkednek el:

A = ; R = chol(A) R = 2,0000 0,5000 1,0000 0 1,9365 0,2582 0 0 1,7127 A - R"*R ans = 0 0 0 0 0 0 -1 0 0

Egy tetszőleges négyzetes mátrixhoz megtehetjük L.U.-bomlás, azaz. megtalálni az alsó háromszögmátrixot Lés felső háromszögmátrix U oly módon, hogy A=LU. Egy szigorúbb kijelentést a következőképpen fogalmazunk meg.

Ha Ak- négyzetmátrix főmoll A méret n, az elsőből összeállított k sorok és oszlopok (azaz A(1:k, 1:k)) és det( A k)0 for k=1,2,..., n-1, akkor van egy egyedi alsó háromszögmátrix L, amelynek átlója egyesekből áll, és az egyetlen felső háromszögmátrix U oly módon, hogy A=LU.

Számításkor L.U. Előfordulhat, hogy egy LU-bővítés sorpermutációt igényel a bővítési folyamat numerikus stabilitásának biztosítása érdekében, így az lu függvény visszaadhat egy mátrixot L, amely alsó háromszög alakú egészen sorpermutációig, például:

A = ; = lu(A) L = 0 1,0000 0 1,0000 0 0 0,5000 0,5000 1,0000 U = 2 3 1 0 1 1 0 0 4

Munka L.U. Ahol L- háromszög alakú a sorok permutációjáig, és egyenlő lesz a mátrixszal A(általában véve, figyelembe véve a valós számokkal végzett műveletek hibáját).

A-L*U ans = 0 0 0 0 0 0 0 0 0

Ha a mátrixhoz A Ha a Cholesky dekompozíció vagy az LU dekompozíció megtörténik, akkor a rendszer megoldása a mátrixszal A, mint fentebb említettük, két rendszer megoldása háromszög mátrixokkal. Ez a megoldás a fordított perjel művelettel valósítható meg, mivel a mögötte lévő algoritmus háromszögmátrixokat azonosít, és hatékony módszert alkalmaz azokkal a rendszer megoldására, amely megköveteli O(n 2) aritmetikai műveletek. Nézzünk egy példát a rendszer megoldására

előzetessel L.U.-mátrixbontás.

A = ; f = ;

végzünk L.U.- bomlás

Lu(A);

és oldjunk meg egymás után két rendszert háromszög mátrixokkal, először L-vel, majd U-val

Y = L\f; x = U\y x = 1 1 1

Két rendszer megoldása egy kifejezésben írható fel

X = U\(L\f)

és az eredmény ugyanaz lesz. Figyelmet kell fordítani a zárójelek használatának fontosságára a háromszögmátrixú rendszerek megoldási sorrendjének meghatározásában. Zárójel nélküli kifejezés

X = U\L\f

teljesen más eredményhez vezet, mivel először hajtják végre U\L, ami egyenértékű (ahogyan fentebb tárgyaltuk) az U mátrixot és L oszlopokat tartalmazó rendszerek megoldásával, mint jobb oldali vektorokkal. Az eredmény egy mátrix, amelynek minden oszlopa a megfelelő rendszer megoldása, majd ezzel a mátrixszal és a jobb oldali f vektorral megoldódik a rendszer. Ennek a folyamatnak nyilvánvalóan semmi köze az eredeti rendszer megoldásához.

Nézzük az utolsó mátrixbontást - QR-a qr függvény által végrehajtott dekompozíció. QR-dekompozíció elvégezhető téglalap alakú mátrixokra, pontosan ha A méretű mátrix m tovább n, akkor van egy ortogonális mátrix K méret m tovább m(azaz olyan, hogy Q -1 =Q T) és a mátrix R méret m tovább n minden nulla elemmel a főátló alatt, amely A=QR.

QR A -kiterjesztés jó számítási stabilitással rendelkezik, és különösen akkor használatos, amikor az adatokat a legkisebb négyzetek módszerével közelítjük. Példaként fontolja meg az előző rendszer QR-bontással történő megoldását:

Qr(A) Q = -0,7428 0,6000 -0,2971 -0,5571 -0,8000 -0,2228 -0,3714 0,0000 0,9285 R = -5,3852 -5,3852 -5,0138 0,060400 0,060,08

Egyszer kész QR-bontás, a rendszer megoldása Ax=f találhatunk megoldást a háromszögmátrix rendszerre R, mert mert a QR=f, Azt Rx=Q T f:

>> x = R\(Q"*f) x = 1,0000 1,0000 1,0000

A mátrixfelbontásokról, a megfelelő MATLAB-függvényekről (chol, lu és qr) és argumentumaikról a Mátrixfelbontások részben olvashat bővebben.

Algoritmus lineáris egyenletrendszer megoldására a fordított perjel segítségével

Lineáris algebrai egyenletrendszer megoldása során MATLAB-ban a fordított perjel segítségével
x = A\b
olyan algoritmus működik, amely a mátrix típusától függően a legmegfelelőbb módszerrel oldja meg a rendszert, a LAPACK vagy UMFPACK csomag valamelyik eljárásában implementálva. Itt b is lehet mátrix, amelynek sorainak száma egybeesik az A mátrix sorainak számával. Ekkor az x mátrixot adjuk vissza, minden i-edik oszlop tartalmazza az Ax (i) = b (i) rendszer megoldását. ) , i=1,2,... ,k, ahol b (i) a b = [ b (1) mátrix i-edik oszlopa | b (2) ...| b(k)].

A \ műveletben megvalósított algoritmus a következő lépésekből áll:

  • 1. A triviális esetben, ha A ritka és átlós (a Ritka mátrixok szakasz a ritka mátrixoknak van fenntartva a MATLAB-ban), a megoldást az x k = b k /a kk egyszerű képlettel találjuk meg, ahol k=1,2,. ..n.
  • 2. Ha A négyzetes, ritka és sávos mátrix, akkor sávmátrix megoldót használunk. Két lehetőség lehet:

    a. Ha A egy háromszögű mátrix és b egy valós számok egyetlen oszlopa, akkor a rendszert Gauss-eliminációval oldjuk meg (műveleteit csak az átlókon lévő elemeken hajtja végre). Ha az eliminációs folyamat során sorpermutációt kell végezni a stabilitás megőrzése érdekében, vagy ha az A mátrix nem háromszögű, akkor a következő pont működik.
    b. Ha A egy olyan szalag, amelynek nullától eltérő elemeinek sűrűsége nagyobb, mint a paraméter bandden, alapértelmezés szerint 0,5, vagy az előző bekezdés feltételei nem teljesülnek, akkor az A és b típustól függően ( kettős vagy egyetlen) a következő LAPACK könyvtári eljárásokat hívják:

    A és b valódi kettősek - DGBTRF, DGBTRS eljárások
    A és b komplex típusú kettős eljárások ZGBTRF, ZGBTRS
    A vagy b valós típusú egyszeres - eljárások SGBTRF, SGBTRS
    A vagy b komplex típusú egyszeres eljárások CGBTRF, CGBTRS

    A nullától eltérő elemek sűrűsége a szalagban lévő nullától eltérő elemek számának és a mátrixszalag összes elemének számának aránya, például egy 7x7-es mátrix esetében, amelynek sablonja adott alább a nullától eltérő elemek számát

    nz = 1 (a -2. számú diagramon) + 6 (a -1. számú diagramon) + 7 (a 0. ábrán) + 6 (az 1. számú diagramon) + 1 (a 2. számú diagramon) + 1 (a 3. ábrán) = 22,

    és a szalag összes elemének száma

    sáv = 5 (a -2. számú diagramon) + 6 (a -1. számú diagramon) + 7 (a 0. ábrán) + 6 (az 1. számú diagramon) + 5 (a 2. ábrán) + 4 (a 3. számú diagramon) = 33

    a nullától eltérő elemek sűrűsége pedig 2/3 lesz. Mivel 2/3 > 0,5, a szalagmátrixok megoldóját használjuk
    Paraméter bandden A MATLAB-ban ritka mátrixalgoritmusokat vezérlő többi paraméterhez hasonlóan a spparms függvény segítségével van beállítva.

    Az algoritmus ezen lépésének az a jelentése, hogy egy rendszer szalagmátrixszal történő megoldása nem igényel szalagon kívüli műveleteket. Ha a hírcsatorna meglehetősen tele van, akkor nem lesz túl sok nulla elemű művelet. Ellenkezőleg, ha a szalag meglehetősen ritka, akkor az algoritmus további lépéseiben megadott megközelítések nagyobb hatást hozhatnak.

  • 3. Ha A felső vagy alsó háromszögmátrix, akkor az inverz helyettesítési módszert, vagy ennek megfelelően a közvetlen helyettesítési módszert alkalmazzuk, amelyben az utolsó (vagy az első egyenletből) megtaláljuk a megoldási komponenst, majd a talált komponenseket behelyettesítve a következő egyenletekbe, hogy megtaláljuk a következő megoldási komponenseket egyenletrendszerek.
  • 4. Ha A - permutációkkal háromszög alakra redukálható, akkor a megfelelő redukciót végrehajtjuk, majd a 3. lépésben leírtak szerint megoldjuk az egyenletrendszert.
  • 5. Ha A szimmetrikus mátrix (vagy összetett esetben hermitikus), és az átlója csak pozitív valós elemeket tartalmaz, akkor attól függően, hogy A ritka vagy sem, az a) vagy a b) tétel teljesül.

    a. Ha A nem ritka, akkor az A = R T R Cholesky-felbontást kíséreljük meg, majd az R T és R háromszögmátrixú rendszereket oldjuk meg: R T y = b és Rx = y. Ebben az esetben a LAPACK könyvtár alábbi eljárásait hívjuk meg:

    A és b valódi és kettős - DLANGE, DPOTRF, DPOTRS, DPOCON
    A és b összetett és kettős - ZLANGE, ZPOTRF, ZPOTRS, ZPOCON
    A és b valódi és egyszeres típusú - SLANGE, SPOTRF, SPOTRS, SDPOCON
    A és b komplex és egyetlen típusú - CLANGE, CPOTRF, CPOTRS, CPOCON

    A Cholesky-felbontás meghiúsul, ha a mátrix nem pozitív határozott. De nincs előzetes ellenőrzés a pozitív meghatározottságra, és pontosan a dekompozíció során határozzák meg, mivel gyakran elegendő a Cholesky-bontás több lépésének elvégzése annak tisztázására, hogy a mátrix nem pozitív határozott (a számítási folyamat szükségessé válik egy negatív szám négyzetgyökének kinyerése). Ha a Cholesky-felbontás nem teljesül, akkor lépjen tovább a következő pontra.

    b. Ha A ritka, akkor először sorok és oszlopok szimmetrikus permutációit hajtjuk végre a szimmetrikus minimális fok algoritmussal (symmmd függvény), hogy csökkentsük a Cholesky-féle dekompozíciós tényező kitöltését, azaz. a töltési folyamat során keletkező új, nullától eltérő elemek számának csökkentése érdekében:

    p = symmmd(A) - p vektor permutációkat tartalmaz

    R = koi(A(p, p));

    és két Cholesky-szorzós rendszer van megoldva, az első egy transzponált szorzóval és a megfelelő permutációkkal a jobb oldali vektorban

    a második pedig egy bővítési tényezővel és a megoldás komponenseinek az x vektor megfelelő pozícióiba való beírásával
    x(p, :) = R\y

  • 6. Ha A egy Hessenberg-mátrix, akkor egy felső háromszögmátrixra redukáljuk (a jobb oldal megfelelő módosításával), majd a rendszert helyettesítésekkel oldjuk meg.
  • 7. Ha A négyzetmátrix, amely nem teljesíti az 1-6. bekezdés feltételeit, akkor attól függően, hogy ritka-e vagy sem, a következő műveleteket hajtjuk végre

    a. Ha A nem ritka mátrix, akkor Gauss-eliminációt használva vezető elem megválasztásával (a dekompozíció stabilitásának biztosítása érdekében) az A = LU mátrix LU-bontását hajtjuk végre, ahol

    U - felső háromszög mátrix
    L egy mátrix, amelyet sorok permutációi háromszög alakúra redukálnak

    az Ax = b rendszer megoldását pedig Ly = b, Ux = y háromszögmátrixú rendszerek szekvenciális megoldásával találjuk meg.
    Az LU dekompozíció végrehajtásához a következő LAPACK könyvtári eljárásokat hívják meg:

    A és b valódi és kettős - DLANGE, DGESV, DGECON
    A és b összetett és kettős - ZLANGE, ZGESV, ZGECON
    A és b valódi és egyszeres típusú - SLANGE, SGESV, SGECON
    A és b összetett és egytípusú - CLANGE, CGESV, CGECON

    b. Ha A egy ritka mátrix, akkor az oszlopokat átrendezzük, hogy csökkentsük az L és U tényezők kitöltését a bontás megtalálásának folyamatában. Továbbá az LU dekompozíció során a sorok átrendezésével biztosítjuk a számítási stabilitást, ami után ismét háromszögmátrixú rendszereket oldanak meg. Egy ritka mátrix LU dekompozíciójának végrehajtásához az UMFPACK könyvtár eljárásait használjuk

    8. Ha az algoritmus előző pontjai nem működtek, és ezért A nem négyzetmátrix, akkor mindent a ritkasága határoz meg, és az alábbi pontok egyike működik:

    a. Ha A nem ritka mátrix, akkor az AP = QR QR dekompozíciót hajtjuk végre, ahol P az oszloppermutációs mátrix, Q az ortogonális mátrix (Q T Q = I), és R a felső háromszög. Ha A mérete m × n, akkor Q mérete m × m, R pedig m × n. Ezután a rendszer megoldása a következő:

    x = P*(R \ (Q" * b))

    mivel Ax = b és AP = QR-ból következik: QRx = bP és Rx = Q T bP.

    b. Ritka és téglalap alakú A mátrix esetén nincs értelme a Q mátrixot számolni, mivel nagy valószínűséggel ki lesz töltve. Ezért a QR dekompozíciós algoritmus kiszámítja a c = Q T b-t (azaz a módosított jobb oldalt), és háromszögmátrixszal oldja meg az Rx = c rendszert, hogy megkapja az eredeti Ax = b rendszer megoldását.

A fentieken túlmenően a fenti algoritmus kiértékeli a mátrix feltételességét, és figyelmeztetést jelenít meg a megoldás lehetséges hibájáról, ha a mátrix rosszul kondicionált (lásd A mátrix feltételrendszerének hatása a pontosságra. rendszer megoldása vele). A fenti algoritmus különféle ellenőrzéseket tartalmaz, amelyek jelentős plusz időt vehetnek igénybe. A következő rész, a Linsolve függvény lineáris egyenletrendszerek megoldásához, bemutatja a linsolve függvényt, amely lehetővé teszi a mátrix típusának megadását, ezáltal csökkentve a számítási időt.

linsolve függvény lineáris egyenletrendszerek megoldására

Ahelyett, hogy lineáris algebrai egyenletek rendszerét (vagy egy mátrixban több jobb oldallal definiált rendszerek) a fordított perjel segítségével oldaná meg, használhatja a linsolve függvényt, amely nem végzi el a \ műveleti algoritmusban rejlő összes mátrixellenőrzést ( lásd az előző részt).

A linsolve függvény a legegyszerűbb formájában hívható meg két bemeneti és egy kimeneti argumentummal
x = linsolve(A, b)
megoldja az Ax = b rendszert az egyik módon, attól függően, hogy a mátrix négyzet alakú-e vagy sem.

  • Ha A négyzetmátrix, akkor először annak LU dekompozícióját számítjuk ki, majd két L és U háromszögmátrixú rendszert oldunk meg.
  • Ha A egy téglalap alakú mátrix, akkor először a QR dekompozícióját számítjuk ki, majd a háromszögmátrixú rendszert oldjuk meg.

(További részleteket a műveletekről a kapott bővítési tényezőkkel a részben írunk). Ezenkívül, ha az A mátrix nem kondicionált, vagy A mátrix nem teljes rangú, akkor egy megfelelő figyelmeztetés jelenik meg, például:

A = ; b = ; x = linsolve(A,b) Figyelmeztetés: Rang hiányos, rang = 1, tol = 4.4686e-015. x = 0 0 2.0000

Ha nem szeretné, hogy ez az üzenet megjelenjen a parancsablakban, hívja meg a linsolve függvényt két kimeneti argumentummal
= linsolve(A, b)
akkor a kapott megoldást x-be írjuk, és r-be - vagy a mátrix rangját (ha A téglalap alakú mátrix), vagy a feltételszám becslésének reciprokát (lásd például a részt).

A = ; b = ; = linsolve(A,b) x = -1,0000e+000 9,9999e-001 3,3307e-006 r = 6,9444e-013

A linsolve függvény fő előnyei a \ művelettel szemben az egyenletrendszer mátrixának megadásakor jelentkeznek. Ehhez a linsolve függvény meghívása előtt ki kell töltenie egy struktúrát a mátrix információival a következő mezőkkel

  • SYM - szimmetrikus;
  • LT - alsó háromszög alakú;
  • UT - felső háromszög alakú;
  • UHESS - Hessenberg;
  • POSDEF - szimmetrikus, pozitív határozott;
  • RECT - téglalap alakú;
  • TRANSA - szükséges-e egy adott rendszerre transzponált mátrixú rendszert megoldani.

Mindegyik mező lehet igaz vagy hamis. Természetesen a mezőértékek nem minden kombinációja érvényes; például egy mátrix nem lehet háromszög alakú, ugyanakkor szimmetrikus és pozitív határozott. A mezőértékek helyes kombinációit a következő táblázat gyűjti össze

LT UT UHESS SYM POSDEF RECT TRANSA
igazhamishamishamishamisigaz hamisigaz hamis
hamisigazhamishamishamisigaz hamisigaz hamis
hamishamisigazhamishamishamisigaz hamis
hamishamishamisigazigazhamisigaz hamis
hamishamishamishamishamisigaz hamisigaz hamis

Ha a rendszer mátrixa pozitív definit, akkor ezt figyelembe kell venni a megoldásnál, mivel pozitív határozott mátrixok esetén a megoldás a Cholesky-felbontáson alapul, ami kevesebb műveletet igényel, mint az általános négyzetmátrixú rendszerek megoldásánál használt LU-felbontás. . Ezt könnyű ellenőrizni a következő példa segítségével, amelyben egy szimmetrikus pozitív határozott mátrixot hozunk létre (egy véletlen számokból álló mátrixot adunk hozzá transzponálva és nagy számokat adunk az átlóhoz) és egy rendszer Az egyenleteket ezzel a mátrixszal először rendszerként oldjuk meg általános alakú mátrixszal (opts. SYM = hamis és opts. POSDEF = hamis), majd szimmetrikus és pozitív határozott mátrixszal (opts.SYM = igaz és opts .POSDEF = igaz).

% beállítja az ops struktúra összes mezőjét, kivéve a SYM és POSDEF opts.TRANSA = false; opts.UHESS = false; opts.RECT ​​= false; opts.UT = false; opts.LT = false; % hozzon létre egy N = 2 méretű mátrix vektort.^(8:12); % üres tömböket hoz létre a megoldási idők rögzítéséhez TimeGeneral = ; TimePosSym = ; % ciklusban mátrixokat hozunk létre és megoldási időket hasonlítunk össze n = N % esetén szimmetrikus és pozitív határozott mátrixot hozunk létre % és a jobb oldal vektorát A = rand(n); A = A + A" + 2*n*eye(n); b = sum(A, 2); % a rendszert általános mátrixú rendszerként oldja meg opts.SYM = false; opts.POSDEF = false; Tstart = cputime; x = linsolve(A,b, opts); Tend = cputime; TimeGeneral = ; % a rendszert szimmetrikus és pozíciómátrixos rendszerként oldja meg az opts.SYM = true; opts.POSDEF = true; Tstart = cputime; x = linsolve( A,b, opts); Tend = cputime; TimePosSym = ; vége % megjelenítési idő grafikonok ábra loglog(N, TimePosSym, N, TimePosSym) legend("TimeGeneral", "TimePosSym")

A rendszer megoldásának ezen módszereinek eredő számítási költségeit az alábbi grafikon mutatja

Természetesen, ha a mátrix háromszög alakú, akkor ezt nagyon fontos jelezni, mivel a háromszög mátrixú rendszer megoldása O(n 2) műveletekben történik, és ha a mátrixra tervezett megoldási algoritmus egy általános formát alkalmazunk egy háromszögmátrixú rendszerre, akkor ez körülbelül O(n 3) műveletet vesz igénybe.

A linsolve függvény nem ellenőrzi, hogy a mátrix megfelel-e a megadott tulajdonságoknak, ami hibát okozhat. Például, ha egy rendszer megoldása során a következő mátrixszal és a jobb oldallal

A = ; b = ; állítsa igaz az UT mezőt (és az összes többi értéket hamisra állítja) opts.UT = igaz; opts.TRANSA = false; opts.LT = false; opts.UHESS = false; opts.SYM = false; opts.POSDEF = false; opts.RECT ​​= false; akkor a rendszer megoldása során a linsolve függvény a mátrixot felső háromszögnek tekinti és a felső háromszögből kiválasztja a számára szükséges elemeket A x = linsolve(A,b, opts) Ez egy x = 1 1 1 megoldást eredményez az A = mátrixnak megfelelő ;

A mátrixfeltételesség hatása a rendszer vele való megoldásának pontosságára

Ebben a részben azt nézzük meg, hogy a jobb oldali vektor elemeinek és az Ax = b lineáris egyenletrendszer mátrixának hibái hogyan befolyásolhatják az adott rendszer megoldását. Térjünk rá először a zavarok bevitelére a jobb oldali b vektorba. Tehát két rendszert oldunk meg

Sőt, feltételezzük, hogy mindegyik rendszert pontosan megoldjuk, és a fő felmerülő kérdés az, hogy az (1) rendszer x megoldása mennyiben lesz más, mint a (2) rendszer megoldása, amelynek jobb oldali δb perturbációja van. Ez egy nagyon fontos kérdés, mivel a jobb oldali elemeket néhány mérés eredményeként kaphatjuk meg, amelyek minden b k komponensben tartalmazzák a δb k hibát. Szeretném, ha azonos mennyiség mérésénél (mindegyik a maga kis hibáival) a kissé eltérő jobb oldali rendszerek megfelelő megoldásai sem nagyon különböznének egymástól. Sajnos ez nem mindig van így. Ennek oka a mátrix egy jellemzője, amelyet annak neveznek feltételesség. Erről még lesz szó.

Először be kell vezetnie a vektorok és az x közelségének mértékét, azaz. hibavektor. Egy vektor nagyságának mértéke a norma (különböző módon definiálható). Egyelőre vegyük normának egy vektor szokásos euklideszi normáját (összetevői négyzetösszegének négyzetgyökét), azaz.

Eszerint

ahol n a rendszerben lévő ismeretlenek és egyenletek száma. A vektor nagyságának becsléséhez szükséges vektornormán kívül szükségünk van egy mátrix normára is a mátrix nagyságának becsléséhez. Vegyük a mátrix normát, amelyet a következőképpen definiálunk (ezt spektrális normának hívják):

azok. a spektrális mátrix normája egyenlő az A T A mátrix maximális sajátértékének négyzetgyökével. A MATLAB-nak van egy normafüggvénye a mátrixok és vektorok normáinak kiszámításához, amely különösen képes kiszámítani a fenti normákat. Hogy miért választottuk ezeket a vektorok és mátrixok sajátos normáit, azt a fejezet részletesen elmagyarázza, ahol néhány számítást és definíciót adunk. Ez összefügg azzal a becsléssel, amelyet a rendszer megoldásánál a hibára fogunk használni (ennek az egyenlőtlenségnek a származtatását is megadjuk az említett részben):

Itt jelöljük a mátrix feltételszámát, amely a következőképpen definiálható:

A fenti egyenlőtlenségből az következik, hogy minél nagyobb a rendszermátrix feltételszáma, annál nagyobb lehet a relatív hiba a megoldásban egy kis hibával a jobb oldalon.

Tekintsünk egy klasszikus példát egy rosszul kondicionált mátrixra - a Hilbert-mátrixra -, és nézzük meg, hogy a rendszer jobb oldalán lévő hiba hogyan befolyásolja a megoldás hibáját. A Hilbert-mátrix meghatározása a következő

Hilbert-mátrix létrehozásához a MATLAB biztosítja a hilb függvényt, amelynek bemeneti argumentuma határozza meg a mátrix méretét. Vegyünk egy kis 6x6 mátrixot:

N=6; H = hilb(n) H = 1,0000 0,5000 0,3333 0,2500 0,2000 0,1667 0,5000 0,3333 0,2500 0,2000 0,1667 0,1667 0,1420 0,07 0,603 0,1429 0,1250 0,2500 0,2000 0,1667 0,1429 0,1250 0,1111 0,2000 0,1667 0,1429 0,1250 0,1111 0,1250 0,1110 0,0101429 111 0,1000 0,0909

X = egyesek(n, 1); b = H*x b = 2,4500 1,5929 1,2179 0,9956 0,8456 0,7365

Látjuk, hogy sem a mátrixban, sem a jobb oldali vektorban nincs semmi „gyanús”, az összes szám nem nagyon különbözik egymástól. Most alakítsuk ki a b + δb perturbált jobb oldalt úgy, hogy kis, 10 -5 nagyságrendű számokat adunk a b vektorhoz, és oldjuk meg a rendszert a perturbált jobb oldallal, hogy megkapjuk a vektort.

Delta_b = 1e-5*(1:n)"; x_tilda = H\(b + delta_b) x_tilda = 0,9978 1,0735 0,4288 2,6632 -1,0160 1,8593

Látható, hogy a kapott megoldás messze nem az a pontos megoldás, ahol minden egységnek lennie kellene. Számítsuk ki a relatív hibát a megoldásban és a jobb oldalon (a normafüggvény alapértelmezés szerint a vektor euklideszi normáját számítja ki):

Delta_x = x - x_tilda; BAL = norma(delta_x)/norm(x) BAL = 1,1475 JOBBRA = norma(delta_b)/norm(b) JOBBRA = 2,7231e-005

Tehát a megoldás hibája egységnyi nagyságrendű, bár a jobb oldalon a változások 10 -5 nagyságrendűek voltak. Ez tökéletesen illeszkedik a fenti hibaegyenlőtlenségbe. Valóban, számítsuk ki a cond(H) feltételszámot a cond nevű MATLAB függvény segítségével, és alapértelmezés szerint a mátrix spektrális normájára

C = feltétel(H) c = 1,4951e+007

BAL ≈ 1.1475 Kevésbé

C* IGAZ? 1,4951e+07 * 2,7231e-05 ≈ 407

és az egyenlőtlenség teljesül (még némi mozgástérrel is).

A Hilbert-mátrix méretének növekedésével a megoldás hibája csak nő (ez könnyen ellenőrizhető n = 7, 8, ... beállításával). Ezenkívül n = 12 esetén egy üzenet jelenik meg, amely szerint a mátrix nem kondicionált, és a megoldás hibás lehet

Figyelmeztetés: A mátrix közel áll az egyes számhoz, vagy rosszul skálázott.
Az eredmények pontatlanok lehetnek. RCOND = 2.409320e-017.

A feltételesség mértékeként az itt választott érték az RCOND egyenlő, egy osztva a feltételszám becsült értékével (a feltételszám becslése egy meglehetősen gyors algoritmus segítségével történik, amely sokkal gyorsabban működik, mint a cond, amelyet részletesebben a súgó ismertet. az rcond funkción). Ha az RCOND értéke kicsi, akkor a mátrixot rosszul kondicionáltnak tekintjük.

A Hilbert-mátrix méretének növekedésével a megoldás hibájának növekedése annak köszönhető, hogy a Hilbert-mátrix feltételszáma nagyon gyorsan növekszik a méretével. Ezt könnyű ellenőrizni egy egyszerű hurok és a szemiológia függvény segítségével (a skála az ordináta tengelye mentén logaritmikus):

N=1:20; C = nullák(1, 20); ha n = N, H = hilb(n); C(n) = kond(H); vége szemilógia(N, C) rács on, title("cond(H)"), xlabel("n")

Egyébként, mivel a kondíció függvény numerikus módszerrel találja meg a feltételszámot (nevezetesen szinguláris kiterjesztéssel szinguláris számok megtalálásához), az n = 12 utáni feltételszámot már nem számítják ki megfelelően, sőt, tovább kell növekednie, ami szimbolikus számításokkal a MATLAB-ban és adott számú szignifikáns számjegyű műveletekkel ellenőrizhető

N=1:20; C = nullák (1, N); számjegyek(60) ha n = N H = vpa(sym(hilb(n))); a Hilbert-mátrix %-os számítása a 60. számjegyig szigma = svd(H); % a Hilbert-mátrix szinguláris értékeinek megtalálása % a Hilbert-mátrix feltételszámának kiszámítása C(n) = max(double(sigma))/min(double(sigma)); vége szemilógia(N, C) rács on, title("cond(H)"), xlabel("n")

Lássunk most három fontos pontot ezzel a példával kapcsolatban.

Ezek közül az első - a Hx = b rendszer megoldása (az egységekből a megoldásnak megfelelő jobb oldali vektorral) a backslash operátor segítségével nem ad pontos mértékegységeket, a hiba már a tizedik számjegyben lesz (bár MATLAB-ban minden a számításokat alapértelmezés szerint kétszeres pontossággal hajtják végre)

Hosszú formátum H\b ans = 0,99999999999916 1,00000000002391 0,99999999983793 1,00000000042209 0,999999999533606 108000001

Ez azért van így, mert a b vektor kiszámításakor, amikor a H mátrixot megszorozzuk az összes vektorral, már beleszámoltunk némi hibát. Ezen túlmenően a kerekítési hibák a rendszer megoldásának folyamatában is szerepet játszottak, és a mátrix rossz feltételessége (még kis méret esetén is) a megoldásban ilyen hibákhoz vezetett. Valójában kis feltételszámú kis mátrixok esetén ilyen hatás nem figyelhető meg. Vegyünk egy 6x6-os véletlenszámú mátrixot, és számítsuk ki a feltételszámát

A = rand(n); kond(A) ans = 57,35245279907571

Ezután minden egységből kialakítjuk a pontos megoldásnak megfelelő jobb oldalt

X = egyesek(n, 1); b = A*x;

és megoldja a rendszert, ami jó pontosságot eredményez

>> 0 A\b ans = 1.000000000000000 1.000000000000000 1.00000000000000 1.00000000000000 1.0000000000000000

A második fontos pont a mátrix determinánsával kapcsolatos. Számítsuk ki annak a 6x6 Hilbert-mátrixnak a determinánsát, amellyel a rendszert megoldottuk

>> det(hilb(6)) ans = 5.3673e-018

A determináns elég kicsinek bizonyul, amiből azt a téves következtetést lehet levonni, hogy a rendszer jobb oldalának kis perturbációjával járó nagy hiba probléma forrása a determináns kicsinysége. A valóságban ez nem így van, ha a rendszer determinánsa kicsi, ez nem jelenti azt, hogy a mátrix rosszul kondicionált, és ezért nagy hiba van a megoldásban. Valóban, vegyük a mátrixot

A = ;

Determinánsa nagyon kicsi, körülbelül 10 -121

Det(A) ans = 9,9970e-121

(a „nagyon” szó természetesen feltételes, de kisebb, mint egy 6x6-os Hilbert-mátrix determinánsa, amivel a rendszer megoldása során problémáink voltak). A determináns kicsisége azonban semmilyen módon nem befolyásolja a megoldás hibáját, amikor a rendszer jobb oldala zavart, ami könnyen kimutatható egy ismert megoldású rendszer kialakításával, a jobb oldali zavarok beiktatásával és megoldásával. a rendszer:

X = ; b = A*x; delta_b = 1e-5*; x_tilda = A\(b+delta_b); delta_x = x - x_tilda; BAL = norma(delta_x)/norm(x) JOBBRA = norma(delta_b)/norm(b) BAL = 2,1272e-005 JOBBRA = 2,1179e-005

Tehát a megoldás relatív hibája majdnem megegyezik a jobb oldali relatív hibával, mivel a fenti A mátrix feltételszáma valamivel nagyobb, mint 1, nevezetesen:

C = kond(A) c = 1,0303

Végezetül pedig nézzük meg a harmadik kérdést, amely a megoldási hiba egyenlőtlenségében való egyenlőségjel elérésére vonatkozik

Vagyis nézzük meg: előfordulhat-e olyan helyzet, amikor egy kis relatív perturbációt végzünk a rendszer jobb oldalán, mondjuk 10 -5, a rendszermátrix feltételszáma 10 10 , és a megoldásban 10 5 relatív hibát kapunk. Rengeteg példán keresztül lehet menni, különböző mátrixokat kipróbálva, nem érheti el az egyenlőséget, és tévesen arra a következtetésre juthat, hogy ez csak felülről jövő túlbecslés a megoldás hibájára. Ez azonban nem így van, amint arról a következő példa is meggyőz bennünket.

amelyben a jobb oldal relatív perturbációja 10 -5

JOBBRA = norma(delta_b)/norm(b) JOBBRA = 1,0000e-005

A rendszer megoldásának relatív hibája 10 5

X = A\b; x_tilda = A\(b+delta_b); delta_x = x - x_tilda; BAL = norma(delta_x)/norm(x) BAL = 1,0000e+005

És ez azért történik, mert
1) ebben a példában az A mátrix feltételszáma 10 10;

C = kond(A) c = 1,0000e+010

2) a megoldás hibájának egyenlőtlensége egyenlőséggé változik.

Ha hosszúra állítjuk a formátumot, akkor azt látjuk, hogy a LEFT, RIGHT és a feltételszám nem pontosan 10 5 , 10 -5 és 10 10 , hanem ez a kerekítési hibák miatt van. Ha egzakt aritmetikával oldjuk meg, akkor az egyenlőség egzakt lenne, ami analitikusan kimutatható (lásd a részt).

A korábbi példákban azt feltételeztük, hogy a mátrix nem tartalmaz hibákat, és a hibák csak a lineáris egyenletrendszer jobb oldalán lehetnek. A gyakorlatban előfordulhat, hogy a rendszermátrix elemei hibásan vannak megadva, pl. a rendszer helyett

|| Axe || V = || b || V ⇒ || A || M || x || V ≥ || b || V

ahol || || M valamilyen mátrix norma. Ennek érdekében a mátrix norma || || M és vektornorma || || V-nek ki kell elégítenie a következő egyenlőtlenséget

|| A || M || x || V ≥ || Axe || V

bármely A mátrixra és x vektorra. Ha ez az egyenlőtlenség fennáll, akkor a mátrixnorma || || M-nek hívják egyeztetett vektornormával || || V. Ismeretes például, hogy a spektrális norma

(az A T mátrix maximális sajátértékének négyzetgyöke) összhangban van az euklideszi vektornormával

Ezért ebben a részben minden kísérletet ezen normák alapján végeztünk.

Miután megkapta az egyenlőtlenséget || A || M || x || V ≥ || b || V jegyezzük meg továbbá, hogy Ax = b-ből az következik, hogy . Mivel az A mátrix nem szinguláris, ebből következik, hogy δx = A -1 δb és || δx || V = || A -1 δb || V. Ismét a normák konzisztenciáját használjuk, és megkapjuk a || egyenlőtlenséget δx || V ≤ || A -1 || M || δb || V. Továbbá a kapott két egyenlőtlenségben

|| A || M || x || V ≥ || b || V és || δx || V ≤ || A -1 || M || δb || V

Az egyik egyenlőtlenség kisebb értékét elosztjuk a másik egyenlőtlenség nagyobb értékével, a nagyobb értékét pedig a kisebbvel.

és egy egyszerű transzformációval végül megkapjuk a szükséges egyenlőtlenséget

ahol kond(A) = || A || M* || A -1 || M.

Vegyük észre, hogy a hiba egyenlőtlenségének származtatása során csak azt a tényt vettük figyelembe, hogy a mátrixnorma konzisztens a vektornormával. Ez nemcsak egy mátrix spektrális normájára és egy vektor euklideszi normájára igaz, hanem más normákra is. Tehát például a képlet alapján kiszámított maximális oszlopmátrix norma

összhangban van az első vektornormával

és a képlettel számított maximális sormátrix norma

összhangban van a végtelen vektor normával

A normafüggvény nemcsak egy vektor euklideszi normáját és egy mátrix spektrális normáját számítja ki, hanem a fent felsorolt ​​vektor- és mátrixnormákat is. Ehhez meg kell hívnia egy további második argumentummal:

  • q = norma(A, 1) - az A mátrix maximális oszlopnormája
  • q = norma(A, inf) - az A mátrix maximális sornormája
  • q = norma(a, 1) - a első vektornormája
  • q = norma(a, inf) - végtelen vektornorma a

Mátrix feltétel száma cond(A) = || A || M* || A -1 || A különböző mátrixnormákra vonatkozó M kiszámítható a kondíció függvény segítségével. Ha a cond-t egy bemeneti argumentummal (mátrixszal) hívjuk, akkor a feltételszámot a spektrális mátrix normához viszonyítva számítjuk ki. A cond függvény további argumentummal történő meghívása a megadott mátrixnormához képest feltételszámokat ad vissza:

  • c = cond(A, 1) - a feltétel száma a mátrix maximális oszlopnormájához viszonyítva
  • с = cond(A, inf) - feltételszám a mátrix maximális sornormájához viszonyítva

Példaként, amely bemutatja a mátrixnorma és a vektornorma konzisztenciájának fontosságát a hibaegyenlőtlenségben, egy példát adunk az A mátrixszal, a jobb oldali b vektorral és a jobb oldali delta_b hibavektorral.

A = ; b = [ -5,7373057243726833e-001 -1,5400413072907607e-001 -5,3347697688693385e-001 -6,0209490373259589e; delta_b = [-0,71685839091451e-5 0,54786619630709e-5 0,37746931527138e-5 0,20850322383081e-5];

Számítsuk ki a becslés jobb és bal részét az első vektornormával, valamint a mátrix feltételszámát a spektrális mátrix normához viszonyítva

JOBBRA = norma(delta_b,1)/norm(b,1); c = kond(A); x = A\b; x_tilda = A\(b+delta_b); delta_x = x - x_tilda; BAL = norma(delta_x,1)/norm(x,1); formátum rövid e disp()

A következő értékeket kapjuk az egyenlőtlenség bal és jobb oldalára
9,9484e+004 9,9323e+004

A bal oldal nem haladhatja meg a jobb oldalt (ahogyan fentebb bizonyítottuk), de az inkonzisztens normák megválasztása miatt nagyobbnak bizonyult.

Vizsgáljuk meg most, hogy egy mátrix feltételszáma miért nem lehet kisebb egynél. Az A mátrix feltételszámát a következőképpen definiáljuk: cond(A) = || A || M* || A -1 || M , ahol || A || M az A valamilyen mátrixnormája. A mátrixnorma (azaz az a szabály, amely alapján egy szám az egyes mátrixokhoz van rendelve) nem lehet tetszőleges, meg kell felelnie a következő négy axiómának:

A1. || A || ≥ 0 bármely A mátrixra és || A || = 0 akkor és csak akkor, ha A nulla mátrix.

A2. || αA || = | α | * || A || bármely A mátrixra és α számra.

A3. || A + B || ≤ || A || + || B || bármely A és B mátrixra

A4. || AB || ≤ || A || * || B || bármely A és B mátrixra.

Az utolsó axiómából világos, hogy a norma csak négyzetmátrixokra van meghatározva (bár a fenti, különféle normák kiszámítására szolgáló képletekben elvileg nincs ilyen korlátozás). Ezenkívül az utolsó axiómából az következik, hogy az I. azonosságmátrix bármely normája nem kisebb egynél, sőt

|| I || = || I*I || ≤ || I || 2 ⇒ || I || ≥ 1.

Ezután ismét a negyedik axiómát használva azt találjuk, hogy a mátrix feltételszáma mindig nagyobb egynél (igaz a mátrix feltételszámára egy tetszőleges mátrixnormához képest)

1 ≤ || I || = || AA -1 || ≤ || A || * || A -1 || = kond(A).

Végezzük el ezt a részt azzal, hogy megvizsgáljuk a pontos egyenlőség megjelenésének okát a megoldás hibájának becslésében, ha a jobb oldalt zavarják:

és megfelelő példákat építünk MATLAB-ban. (Az alábbi vitát például J. Forsythe, K. Mohler. Lineáris algebrai egyenletrendszerek numerikus megoldása című könyve tartalmazza. M: „Mir”, 1969.)

Az érvelésben lényeges szerepet játszik a mátrix szinguláris dekompozíciójára vonatkozó tétel, amely szerint bármely n méretű valós mátrixhoz létezik két n x n méretű ortogonális U és V mátrix (U T U=UU T és V T V = VV T) úgy, hogy a D = U T AV szorzat átlós mátrix legyen, és választhatunk U és V úgy, hogy

ahol μ 1 ≥ μ 2 ≥…≥μ r ≥ μ r+1 =…=μ n =0,

és r az A mátrix rangja. A μ k számokat az A mátrix spektrális számainak nevezzük. Egy nem szinguláris A mátrixra a következő igaz:

μ 1 ≥ μ 2 ≥ … ≥ μ n ≥ 0.

A következő fontos tény, hogy az ortogonális mátrixszal való szorzás nem változtatja meg a vektor euklideszi normáját, azaz. minden n elemű x vektorra és bármely n x n méretű U ortogonális mátrixra igaz az egyenlőség

|| Ux || = || x ||.

Mivel az ortogonális mátrixszal való szorzás nem változtatja meg a spektrális normát, akkor

ezért a mátrix feltételszámára a következő egyenlőség igaz:

Két rendszerünk van: Ax = b (x pontos megoldással) és (pontos megoldással ). Nyilvánvalóan a δx hiba egy olyan rendszer megoldása, amelynek jobb oldala egy δb perturbáció, azaz. rendszerek Aδx = δb. Legyen D = U T AV az A mátrix szinguláris értékű dekompozíciója, majd UDV T = A, mivel U és V ortogonális mátrixok. További

Ax = b ⇒ UDV T x = b.

Bemutatjuk a jelölést

x" = V T x, b" = U T b,

akkor a következő rendszerek egyenértékűek

Ax = b ⇔ Dx" = b"

Teljesen hasonló módon tekintsük a rendszert a hiba szempontjából

Aδx = δb ⇒ UDV T δx = δb

Bemutatjuk a jelölést

δx" = V T δx, δb" = U T δb,

amelyekre a következő rendszerek egyenértékűnek bizonyulnak

Aδx = δb ⇔ Dδx" = δb"

Azok. egyszerű ekvivalens rendszereket kaptunk egy diagonális mátrixszal, amelynek átlóján az A mátrix spektrális számai találhatók.

Válasszuk ki most ezeknek a rendszereknek a jobb oldalát egy speciális módon, nevezetesen, legyen

ahol β > 0, akkor a Dx" = b" rendszer megfelelő megoldása lesz

ahol μ 1 az A mátrix maximális szinguláris értéke. Ugyanezt tesszük a Dδx" = δ b" rendszerrel, azaz legyen

ahol γ > 0, akkor a Dδx" = δb" rendszer megfelelő megoldása lesz

Egy vektor normájának megőrzéséből, ha azt ortogonális mátrixszal szorozzuk, az következik, hogy

β/μ 1 = || x" || = || V T x || = || x || és γ/μ n = || δx" || = || V T δx || = ||δx ||.

Pontosan ugyanígy megkapjuk az egyenlőségeket:

β = || b" || = || U T b || = || b || és γ = || δb" || = || U T δb || = || δb ||.

és azóta

akkor végre megkapjuk

Tehát minden A mátrixhoz létre lehet hozni egy vektort a rendszer jobb oldalára és annak perturbációjára úgy, hogy a megoldásban a hiba a mátrix feltételszámának és a jobb oldali hibának a szorzata legyen. A MATLAB-ban a megfelelő konstrukció elvégezhető szinguláris érték dekompozíció használata nélkül (bár ez megtalálható az svd függvény használatával).

Először beállítjuk n-t, és két ortogonális U és V mátrixot kapunk úgy, hogy n n mátrixot véletlenszerű számokból QR-felbontással végezzük:

N=4; = qr(rand(n)); = qr(rand(n));

D = diag();

Ezt követően megszerkesztjük az A mátrixot a D átlós mátrix és az U és V ortogonális mátrixok segítségével.

A = U*D*V";

Az A mátrix feltételszáma egybe fog esni a D mátrix feltételszámával, ami példánkban egyenlő 10 10

Béta = 1; gamma = 1e-5;

és építsd fel a b" és δb" vektorokat

B1 = "; db1 = ";

amelyből megtaláljuk a b és δb vektorokat

X = A\b; x_tilda = A\(b+db);

számítsa ki az egyenlőtlenség bal és jobb oldalát!

dx = x - x_tilda; JOBBRA = norma(db)/norm(b); BAL = norma(dx)/norm(x);

és hozd ki őket

Rövid formátum e disp()

Egyenlőséget kapunk

1.Parancsablak(Parancsablak).

A matematikai kifejezések a " >> " prompt utáni parancssorba kerülnek. Például,

A művelet végrehajtásához nyomja meg az „Enter” billentyűt.

Alapértelmezés szerint a program az eredményt az ans speciális változóba írja.

Ha az eredményt más néven szeretné menteni, használja például a változó nevét és a hozzárendelési jelet „=”.

>> z = 1,25 /3,11

Szerkesztés be Parancsablak Csak az aktuális parancssort használhatja. Egy korábban megadott parancs szerkesztéséhez a kurzort a beviteli sorba kell helyezni, és a „ ” vagy a „ ” gombokat kell használni.

Ha egy parancs „;”-re végződik, akkor a művelet eredménye nem jelenik meg a parancssorban.

A parancsablak a „ ” gombbal zárható be, a „ ” gomb pedig az ablak és a rendszerfelület elválasztására szolgál. A normál ablakformához a menü segítségével térhet vissza:

FőmenüAsztaliAsztali elrendezésAlapértelmezett.

A parancsablakot a menü segítségével törölheti:

FőmenüSzerkesztésParancsablak törlése.

A MatLab rendszer főmenüje.

Főmenü MatLab a következő elemeket tartalmazza:

Fájl(Fájl) – fájlokkal való munka;

Szerkesztés(Szerkesztés) – szerkesztés;

Kilátás(View) – ablakkezelés;

Web– kommunikáció a fejlesztő céggel az interneten keresztül;

Ablak(Window) – kapcsolat rendszerablakokkal;

Segítség(Súgó) – hivatkozás a súgórendszerre MatLab.

MATLAB rendszer eszköztár.

Az eszköztár gombjai a következő célokat szolgálják:

Új fájl(Új) – megjeleníti a fájlszerkesztő ablakokat;

Fájl megnyitása(Megnyitás) – fájlletöltő ablakok megnyitása;

Vágott(Vágás) – kivágja a kiválasztott töredéket, és a vágólapra helyezi;

Másolat(Másolás) – a kiválasztott töredéket a vágólapra másolja;

Paszta(Beillesztés) – átviszi a kiválasztott töredéket a vágólapról a beviteli sorba;

Visszavonás(Mégse) – törli az előző művelet eredményét;

Újra(Repeat) – megismétli az előző művelet eredményét;

Simulink– Simulink modellt hoz létre (bővítmények MatLab);

Súgó ablak(Súgó) – megnyitja a súgóablakot.

4. A számítási eredmények kimeneti formátuma .



Valós számok beírásakor a tört rész elválasztására egy pont szolgál!

>> s = 0,3467819

A számítás eredménye formátumban jelenik meg rövid(egy szám rövid jelölése), amely alapértelmezés szerint definiálva van. A formátumot módosíthatja hosszú(hosszú szám jelölés).

>> formátum hosszú

0.34678190000000

A listán Numerikus formátum elérhető számformátumok

rövid– a szám rövid jelölése;

hosszú– hosszú számjelölés;

rövid e– egy szám rövid jelölése lebegőpontos formátumban;

hosszú e– egy szám hosszú rekordja lebegőpontos formátumban;

rövid g– egy szám rövid jelölésének második formája;

hosszú g– a szám hosszú jelölésének második formája;

A numerikus adatok megjelenítési formátuma a menüben állítható be Fájl(fájl) elem preferenciák(preferenciák). Ugrás a lapra Parancsablak(parancsablak). Opcióban Szöveg megjelenítése(szöveges megjelenítés), listában Numerikus formátum(numerikus formátum) készlet rövid g, opcióban Numerikus kijelző(számok megjelenítése) beállítva kompakt. Ezek a kimeneti formátumok univerzális, öt jelentős számjegyből álló számokat adnak ki, és elnyomják a sorok közötti szóközt.

A számítások alapjai a MatLab-ban.

Egyszerű aritmetikai műveletek végrehajtásához MatLab operátorokat használnak:

· összeadás és kivonás +, – ;

· szorzás és osztás *, / ;

· hatványozás ^ .

Néhány speciális változó:

ans – az utolsó művelet eredménye hozzárendelési jel nélkül;

eps – relatív hiba a lebegőpontos számításokban;

pi – szám;

i vagy j – képzeletbeli egység;

Inf – végtelen;

NaN – meghatározatlan érték.

Néhány beépített elemi funkcióMatLab:

exp(x) – az x szám kitevője;

log(x) – az x szám természetes logaritmusa;

sqrt(x) – az x szám négyzetgyöke;

abs(x) – az x szám modulusa;

sin(x), cos(x), tan(x), cot(x) – az x szám szinusz, koszinusz, érintő, kotangens;

asin(x), acos(x), atan(x), acot(x) – arcszinusz, arccosinusz, arctangens, x szám arkotangense;

sec(x), csc(x) – az x szám szekánsa, koszekánsa;

round(x) – az x szám kerekítése a legközelebbi egész számra;

mod(x,y) – x egész szám y-val való osztásának maradéka, figyelembe véve az előjelet;

jel(x) – adja vissza az x szám előjelét.

Számítsuk ki a kifejezés értékét

>> exp(–2.5)*log(11.3)^0.3 – sqrt((sin(2.45*pi)+cos(3.78*pi))/tan(3.3))

Ha az operátor nem helyezhető el egy sorba, akkor a következő sorban folytathatja a beírását, ha az első sor végén a „…” folytatójelet jelzi, pl.

>> exp(–2,5)*log(11,3)^0,3 – ...

sqrt((sin(2.45*pi)+cos(3.78*pi))/tan(3.3))

Funkciók komplex számokkal való munkavégzéshez:

Komplex szám beírása

>> z = 3 + 4i

3.0000 + 4.0000i

Az abs(z), szög(z) függvények egy komplex szám modulusát és argumentumát adják vissza, ahol , ;

komplex(a,b) valós és imaginárius részéből komplex számot állít össze:

conj(z) a komplex konjugált számot adja vissza;

imag(z), real(z) a z komplex szám imagináris és valós részét adja vissza.

6. Vektorok.

Szám beírása, összeadása, kivonása, szorzása.

Vektor be MatLab szögletes zárójeles operátor segítségével alakítjuk ki. Ebben az esetben az oszlopvektor elemeit pontosvessző „;”, a sorvektor elemeit pedig szóköz „” vagy vessző „,” választja el.

Vezessünk be egy oszlopvektort.

>> x =

Vezessünk be egy sorvektort .

>> y =

Egy vektor transzponálásához használja a „’” aposztrófot:

>> z = y'

A vektorok összegének és különbségének meghatározásához használja a „+” és „–” jeleket:

>> c = x + z

A vektor számmal való szorzása mind a jobb, mind a bal oldalon történik a „*” jel használatával.

A vektorok argumentumai lehetnek a beépített függvényeknek, pl.

>> d = bűn(c)

A vektorok elemeire való hivatkozáshoz zárójeleket () használnak, pl.

>> x_2 = x(2)

A vektor utolsó eleme a parancs beírásával választható ki

>> X_end = x(vége)

Több vektorból készíthet például egyet

>> r =

1.3 5.4 6.9 7.1 3.5 8.2

A " : " kettőspont karakter például több elem elválasztására szolgál egy vektortól

>> w = r(3:5)

A " : " kettőspont lehetővé teszi egy vektor elemeinek cseréjét is, például

>> r(3:5)= 0

1.3 5.4 0 0 0 8.2

A „:” szimbólum segítségével olyan vektort is szerkeszthetünk, amelynek minden eleme konstans számmal különbözik az előzőtől, pl. lépés például

>> h =

1 1.2 1.4 1.6 1.8 2

A lépés lehet negatív (ebben az esetben a kezdő számnak nagyobbnak kell lennie, mint a végső szám).

Az eggyel egyenlő lépés elhagyható

>> k =

Alapvető függvények a vektorokkal való munkavégzéshez.

  • hossz(x) – az x vektor hosszának meghatározása;
  • prod(x) – az x vektor összes elemének szorzása;
  • sum(x) – az x vektor összes elemének összegzése;
  • max(x) – az x vektor maximális elemének megtalálása;
  • min(x) – az x vektor minimális elemének megtalálása.

Ha a min vagy max függvényt két kimeneti argumentummal hívja meg = min(x),

akkor az első változóhoz a minimális (maximális) elem értéke, a második változóhoz pedig ennek az elemnek a száma.

7 Mátrixok.

Különféle mátrix beviteli módszerek.

1. Egy mátrix beírható oszlopvektorként, amely két elemből áll, amelyek mindegyike sorvektor és pontosvesszővel van elválasztva. Például mutassuk be a mátrixot

>> A =

2. A mátrixot soronként lehet bevinni a következő parancsok végrehajtásával:

>> A = )