bilinearis egyenletrendszer

Hi!

Ha nem programba kell, akkor talan a Matlab megoldja. Bar ahogy latom, nem ez a helyzet.

By(t)e
TBS::Antiemes

Szamolj vegig egy altalanos esetet kezzel!

4A = A_00 + A_10*x + A_01*y + A_11*x*y
4B = B_00 + B_10*x + B_01*y + B_11*x*y

Szorozzuk vegig ugy, hogy az xy-os tag kiessen, ha kivonjuk egymasbol.
Marad valami C_1=C_2*x+C_3*y alaku, ami visszahelyettesitheto az egyikbe, marad egy masodfoku egyenlet, amit megoldasz a keplettel.
Amikor utana lekodolod, nyilvan le kell kezelni, ha valami 0 (0-val osztas), ha valami kiesne, es emiatt nem oszthatsz le vele, ha A_11 es B_11 is 0, stb.. de ez mar annyit nem bonyolit a dolgon. A kezi parameteres megoldas alapjan nem tunik lehetetlennek lekodolni.

----
-FLOSSzine: Ha 48 óráig Theo lehetnél, mire fordítanád a rendelkezésedre álló időt?
-Nagy Róbert: Úgy viselkednék Theo-val ahogy ő szokott, csak hogy átérezze :)
honlapkészítés

Remélem, jól értem a kérdést. Az A, B, A_ij, B_ij (i, j {0,1}-ben) mind paraméter, ugye?

1. Tegyük fel, A_11 = 0. Akkor az első egyenletből kapsz x és y között egy lineáris összefüggést, amit beteszel a másodikba, és azt megoldod másodfokú egyenletként. (Természetesen mindenhol figyelve, hogy amivel osztanál vagy szoroznál, az nem nulla. Igazából ezt az 1-es pontot is csak azért veszem külön, mert majd A_11-gyel akarok szorozni.)

2. Most inkább azt tegyük fel, hogy B_11 = 0. Ez az 1-es ponttal szimmetrikus.

3. Most azt tegyük fel, hogy A_11 != 0 és B_11 != 0. Ekkor az első egyenletet szorozd meg B_11-gyel, a másodikat pedig A_11-gyel. Így mindkettő végén A_11 * B_11 * x * y fog állni. Az egyikből vond ki a másikat, és kapsz eegy lineáris összefüggést x és y között, amit az eredeti két egyenlet akármelyikébe behelyettesíthetsz, és egy egyváltozós másodfokú egyenletet kapsz.

Figyelj arra, hogy ne ossz nullával, ne szorozz nullával, és hogy a másodfokú egyenletnek lehet 0, 1, 2 (valós) megoldása. Szerintem jó sok külön eseted lesz.

Ha matematikailag megvan a levezetés, akkor elkezdhetsz azon gondolkozni, hogy lebegőpontos ábrázolással milyen sorrendben számolj, hogy a 0-kat "jól" zárd ki, és egyáltalán, meg tudd becsülni és minimalizálni tudd a hibát. (Ne felejtsük el, hogy lebegőpontos ábrázolásnál általában véve nem érvényes az az asszociativitás és disztributivitás, amit a matematikában az alapműveleteknél "megszoktunk".)

A lebegőpontos aritmetikát numerikus analízisben alkalmazott közelítésekre találták ki. Ezért épeszű C programozó addig nem nyúl a lebegőpontos típusokhoz és függvényekhez, amíg nem abszolút elkerülhetetlen.

http://hal.archives-ouvertes.fr/hal-00128124
http://www.lahey.com/float.htm
http://docs.sun.com/source/806-3568/ncg_goldberg.html
http://en.wikipedia.org/wiki/Floating_point

Nincs ebben semmi különleges. Ha az első egyenletből kifejezem y-t, és behelyettesítem a másodikba, akkor egy sima másodfokú egyenletrendszert kapok. Amit mindenki meg tud már oldani. Az egyedüli nehézség, hogy sok tagból áll az egyenlet, és oda kell figyelni az előjelekre, meg arra, hogy mit mivel szorzunk be.

Írtam egy kis minta Java programot, ami ki tudja számítani a gyököket. Ebben csak a valós megoldásra koncentráltam, arra nem, hogy mi a helyzet nem valós gyökök esetén:

package bilinearis;

public class Main {
    
    static double A = 10;
    static double A_00 = 12;
    static double A_10 = 5;
    static double A_01 = 7;
    static double A_11 = 6;
    static double B = 4;
    static double B_00 = 3;
    static double B_10 = 6;
    static double B_01 = 3;
    static double B_11 = 6;
    
    public static double yCalc(double x) {
        return (4*A - A_00 - A_10*x) / (A_01 + A_11*x);
    }
    
    public static void main(String[] args) {
        
        double a = A_11*B_10 - A_10*B_11;
        double b = A_01*B_10 + A_11*B_00 + 4*A*B_11 -
                A_10*B_01 - A_00*B_11 - 4*B*A_11;
        double c = A_01*B_00 + 4*A*B_01 - A_00*B_01 - 4*B*A_01;
        
        double gyokAlatt = b*b - 4*a*c;
        if (gyokAlatt >= 0  &&  a != 0) {
            double x1 = (-b + Math.sqrt(gyokAlatt)) / 2 / a;
            double x2 = (-b - Math.sqrt(gyokAlatt)) / 2 / a;
            double y1 = yCalc(x1);
            double y2 = yCalc(x2);
            System.out.println("x1 = " + x1 + "  x2 = " + x2);
            System.out.println("y1 = " + y1 + "  y2 = " + y2);
            
            // Ellenőrzés x1-re:
            System.out.println("4*A = " + 4*A);
            double ertek1 = A_00 + A_10*x1 + A_01*y1 + A_11*x1*y1;
            System.out.println("A_00 + A_10*x1 + A_01*y1 + A_11*x1*y1 = " + ertek1);
            System.out.println("4*B = " + 4*B);
            double ertek2 = B_00 + B_10*x1 + B_01*y1 + B_11*x1*y1;
            System.out.println("B_00 + B_10*x1 + B_01*y1 + B_11*x1*y1 = " + ertek2);

        }
    }

}

Ezen konkrét paraméterekkel ezt a megoldást adta a program:

   x1 = 0.05964661273109565  x2 = -19.559646612731097
   y1 = 3.7649116531827755  y2 = -1.1399116531827742
   4*A = 40.0
   A_00 + A_10*x1 + A_01*y1 + A_11*x1*y1 = 40.0
   4*B = 16.0
   B_00 + B_10*x1 + B_01*y1 + B_11*x1*y1 = 15.999999999999993