(*==========================================================================*) (* *) (* PASCAL-XSC - MODUL LIVP_MPS 000222 *) (* *) (* MODUL ZUR LOESUNG DES ANFANGSWERTPROBLEMS ZUR DGL *) (* *) (* y^(n) = \sum_(i=0)^(n-1) p_i(x) y^(i) + p(x), p(x), p_i(x) analytisch *) (* *) (* POTENZREIHENANSATZ: y(x) = \sum_0^infty a_k x^k *) (* LOESUNG MIT VARIABLER TAYLORENTWICKLUNG UND RESTGLIEDABSCHAETZUNG *) (* RECHNUNG MIT ADAPTIVER GENAUIGKEIT *) (* *) (* VERSION FUER RECORD-BASIERTE MPS-ARITHMETIK *) (* *) (*==========================================================================*) MODULE livp_mps; USE iostd , i_ari , mv_ari , mvi_ari , service , mps_aril; GLOBAL TYPE INTEGERVECTOR = GLOBAL DYNAMIC ARRAY[*] OF INTEGER; (*--------------------------------------------------------------------------*) GLOBAL PROCEDURE LIVP( N : INTEGER; INHOM : BOOLEAN; VRM : INTEGERVECTOR; VRB : RVECTOR; TIB : MPMATRIX; KOEFPREC : INTEGER; VRY : RVECTOR; X_END , OMEGA , E_ABS : REAL; T_IND : INTEGER; VAR FAK : RVECTOR; VAR PRODINDEX : INTEGER; VAR PROD: RMATRIX; VAR IPROD: IMATRIX; VAR VIZ : IVECTOR; VAR OUTFILE , CONSOLE : TEXT ); CONST KMAX = 300 ; (* MAXIMALE ORDNUNG DER TAYLORENTWICKLUNG *) (* VARIABLEN : *) (* N : ORNUNG DER DIFFERENTIALGLEICHUNG *) (* PROD : HILSVARIABLE: PROD[I,J] := ( I+1 ) * ( I+2 ) *...* ( I+J ) *) (* TIA : TAYLORKOEFFIZIENTEN a_k * h^k DER LOESUNG *) (* VRM : INDEX, AB DEM SCHRANKE FÜR TAYLORKOEFFIZIENTEN VERFÜGBAR *) (* VRB : SCHRANKE FÜR TAYLORKOEFFIZIENTEN DER KOEFFIZENTENFUNKTIONEN *) (* TIB : TAYLORKOEFFIZIENTEN DER KOEFFIZENTENFUNKTIONEN *) (* VIZ : FUNKTIONSWERTE DER N-1 ERSTEN ABLEITUNGEN AN DER STELLE X_END *) (* VRY : ANFANGSWERTE DER N-1 ERSTEN ABLEITUNGEN *) (* X_END : RECHTE GRENZE DES DEFINITIONSINTERVALLS DER DGL *) (* VORAUSSETZUNG AN PROD: DIE IN PROD BERECHNETEN PRODUKTE *) (* (MAXIMAL NMAX + KMAX FAKTOREN) MUESSEN EXAKT DARSTELLBAR SEIN *) (* (SONST KOENNTE MAN EINE LANGZAHLDARSTELLUNG VERFUEGBAR MACHEN) *) VAR I , J , K , L , M : INTEGER; AMAX , AMAX_TOP , ANEU : REAL; AMAX_TOP_ALT : REAL; KOEFSUM , RESTGLIED : REAL; KOEFSUM1 , KOEFSUM2 : REAL; KOEFSUM3 , Q1 , Q2 , Q : REAL; RADIUS , DURCHMESSER : REAL; MAXSUMMAND , SKALFAKT : REAL; UNTERLAUF , FINISHED : BOOLEAN; REIHE , IREST : IVECTOR[0..N]; MPX_END : MPVECTOR[0..KMAX+N]; TIA : MPVECTOR[0..KMAX]; MULTIP : MPMATRIX[0..N-1,0..KMAX]; IX_END : INTERVAL; (*--------------------------------------------------------------------------*) PROCEDURE AUSFILE1( K : INTEGER ); (* PROZEDUR ZUR AUSGABE VON ZWISCHENERGEBNISSEN IN DAS FILE OUTFILE *) VAR I : INTEGER; BEGIN WRITELN( OUTFILE ); FOR I := 1 TO TIA[K].PREC DO BEGIN WRITE( OUTFILE , K : 3 , '. Summand = ' ); IF UNTERLAUF THEN BEGIN WRITE( OUTFILE , TIA[K].STAG[I] ); WRITELN( OUTFILE , ' (skal.)' ); END ELSE WRITELN( OUTFILE , TIA[K].STAG[I] ); END; IWRITELN( OUTFILE , TIA[K].INT ); WRITE( OUTFILE , K : 3 , '. Reihe = ' ); IF UNTERLAUF THEN BEGIN IWRITE( OUTFILE , REIHE[0] ); WRITELN( OUTFILE , ' (skal.)' ); END ELSE IWRITELN( OUTFILE , REIHE[0] ); WRITE( OUTFILE , K : 3 , '. Restglied : ' ); WRITELN( OUTFILE , RESTGLIED ); WRITE( OUTFILE , K : 3 , '. max. Wachstum : ' ); WRITELN( OUTFILE , KOEFSUM ); END; (*--------------------------------------------------------------------------*) PROCEDURE AUSFILE2( K : INTEGER ); (* PROZEDUR ZUR AUSGABE VON ZWISCHENERGEBNISSEN IN DAS FILE OUTFILE *) VAR I : INTEGER; BEGIN WRITELN( OUTFILE ); FOR I := 1 TO TIA[K].PREC DO BEGIN WRITE( OUTFILE , K : 3 , '. Summand = ' ); IF UNTERLAUF THEN BEGIN WRITE( OUTFILE , TIA[K].STAG[I] ); WRITELN( OUTFILE , ' (skal.)' ); END ELSE WRITELN( OUTFILE , TIA[K].STAG[I] ); END; IWRITELN( OUTFILE , TIA[K].INT ); WRITELN( OUTFILE ); FOR I := 0 TO N - 1 DO BEGIN WRITE( OUTFILE , 'Reihe fuer y^(' , I : 1 , '): ' ); IF UNTERLAUF THEN BEGIN IWRITE( OUTFILE , REIHE[I] ); WRITELN( OUTFILE , ' (skal.)' ); END ELSE IWRITELN( OUTFILE , REIHE[I] ); END; FOR I := 0 TO N - 1 DO BEGIN WRITE( OUTFILE , 'Restgl. fuer y^(' , I : 1 , '): ' ); IF UNTERLAUF THEN BEGIN IWRITE( OUTFILE , IREST[I] ); WRITELN( OUTFILE , ' (skal.)' ); END ELSE IWRITELN( OUTFILE , IREST[I] ); END; END; (*--------------------------------------------------------------------------*) PROCEDURE PRODUCTS( K : INTEGER; VAR PRODINDEX : INTEGER ); (* (K+N)-TE PRODUKTE BERECHNEN *) VAR I , J : INTEGER; BEGIN FOR I := 0 TO N DO BEGIN IPROD[K+N-I,I] := IPROD[K+N-I-1,I] * ( K + N ) / ( K + N - I ); IF IPROD[K+N-I,I].INF < IPROD[K+N-I,I].SUP THEN BEGIN WRITELN; WRITELN( 'Fehler in Modul LIVP_MPS' ); WRITELN( 'IPROD in Prozedur PRODUCTS nicht exakt darstellbar.' ); WRITELN; END ELSE PROD[K+N-I,I] := IPROD[K+N-I,I].INF; END; PRODINDEX := K; END; (*--------------------------------------------------------------------------*) PROCEDURE TAYKOEFF_HOM( K : INTEGER ); (* K+N-TEN TAYLORKOEFFIZIENTEN FUER HOMOGENE DGL BERECHNEN *) VAR I , J , PREC : INTEGER; DPL , DPU : DOTPRECISION; BEGIN DPL := #( 0 ); DPU := DPL; FOR I := 0 TO N - 1 DO FOR J := 0 TO K DO ADD_MP_TIMES_MP( DPL , DPU , PROD[K-J,I] *> MULTIP[I,J] , TIA[K-J+I] ); TIA[K+N] := CONVERT( DPL , DPU , KOEFPREC ); TIA[K+N].PREC := KOEFPREC; TIA[K+N] := TIA[K+N] / PROD[K,N]; (* PROD IST PUNKTINTERVALL *) (* EVENTUELL VORGETAEUSCHTE GENAUIGKEIT REDUZIEREN *) PREC := KOEFPREC; WHILE ( ( PREC > 1 ) AND ( TIA[K+N].STAG[PREC] = 0 ) ) DO PREC := PREC - 1; WHILE ( ( PREC > 1 ) AND ( ABS( TIA[K+N].STAG[PREC] ) < ABS( TIA[K+N].INT.INF ) + ABS( TIA[K+N].INT.SUP ) ) ) DO BEGIN TIA[K+N].INT := TIA[K+N].INT + TIA[K+N].STAG[PREC]; TIA[K+N].STAG[PREC] := 0; PREC := PREC - 1; END; TIA[K+N].PREC := PREC; END; (*--------------------------------------------------------------------------*) PROCEDURE TAYKOEFF_INHOM( K : INTEGER ); (* K+N-TEN TAYLORKOEFFIZIENTEN FUER INHOMOGENE DGL BERECHNEN *) VAR I , J , PREC : INTEGER; DPL , DPU : DOTPRECISION; BEGIN DPL := #( 0 ); DPU := DPL; FOR I := 0 TO N - 1 DO FOR J := 0 TO K DO ADD_MP_TIMES_MP( DPL , DPU , PROD[K-J,I] *> MULTIP[I,J] , TIA[K-J+I] ); ADD_MP_TIMES_MP( DPL , DPU , MPX_END[K+N] , TIB[-1,K] ); TIA[K+N] := CONVERT( DPL , DPU , KOEFPREC ); TIA[K+N].PREC := KOEFPREC; TIA[K+N] := TIA[K+N] / PROD[K,N]; (* EVENTUELL VORGETAEUSCHTE GENAUIGKEIT REDUZIEREN *) PREC := KOEFPREC; WHILE ( ( PREC > 1 ) AND ( TIA[K+N].STAG[PREC] = 0 ) ) DO PREC := PREC - 1; WHILE ( ( PREC > 1 ) AND ( ABS( TIA[K+N].STAG[PREC] ) < ABS( TIA[K+N].INT.INF ) + ABS( TIA[K+N].INT.SUP ) ) ) DO BEGIN TIA[K+N].INT := TIA[K+N].INT + TIA[K+N].STAG[PREC]; TIA[K+N].STAG[PREC] := 0; PREC := PREC - 1; END; TIA[K+N].PREC := PREC; END; (*--------------------------------------------------------------------------*) PROCEDURE KOEFSUMS; (* KOEFSUM WIRD FUER DEN INDEX K+N+1 BERECHNET *) (* ALLE VARIABLEN AUSSER DEN SCHLEIFENINDIZES I UND J SIND GLOBAL *) VAR I , J , NU : INTEGER; BEGIN KOEFSUM1 := 0; KOEFSUM2 := 0; KOEFSUM3 := 0; FOR I := 0 TO N - 1 DO FOR J := 0 TO VRM[I] DO KOEFSUM1 := KOEFSUM1 + ABS_SUP( PROD[K+1-J,I] *> MULTIP[I,J] ) / ( ( OMEGA ** ( N-I+J ) ) * PROD[K+1,N] ); FOR I := 0 TO N - 1 DO IF VRM[I] >= N THEN KOEFSUM2 := KOEFSUM2 + VRB[I] * PROD[K+1-VRM[I]-1,I+1] / ( ( I+1 ) * ( RADIUS ** I ) * PROD[K,N] ); KOEFSUM2 := KOEFSUM2 / PROD[K+1,N]; IF INHOM THEN BEGIN KOEFSUM3 := VRB[-1] / PROD[K+1,N]; END; (* BERUECKSICHTIGUNG VON RUNDUNGSFEHLERN DER OBIGEN OPERATIONEN *) KOEFSUM1 := KOEFSUM1 * 1.000000000001; KOEFSUM2 := KOEFSUM2 * 1.000000000001; KOEFSUM3 := KOEFSUM3 * 1.000000000001; Q1 := AMAX_TOP /> AMAX; Q2 := ( KOEFSUM2 +> KOEFSUM3 /> AMAX ) /> ( 1 -< KOEFSUM1 ); Q := Q1; IF ( Q2 < 0 ) OR ( Q2 > Q1 ) THEN Q := Q2; (* FEHLERABSCHAETZUNG DURCHFUEHRBAR, FALLS 0 <= Q <= 1 *) (* KOEFSUM IST EINE UNTERSCHRANKE FUER Q *) (* NUR BERECHNET, UM EVENTUELLE UEBERSCHAETZUNG VON Q ZU BESTIMMEN *) KOEFSUM := ( ( KOEFSUM1 * AMAX_TOP + KOEFSUM3 ) / AMAX + KOEFSUM2 ); (* ZWISCHENERGEBNISSE AUSDRUCKEN *) WRITELN( OUTFILE ); WRITELN( OUTFILE ); WRITE( OUTFILE , 'KOEFSUM1 , KOEFSUM2 , KOEFSUM3 , KOEFSUM , ' ); WRITELN( OUTFILE , 'AMAX_TOP , AMAX , Q1 , Q2' ); WRITELN( OUTFILE , KOEFSUM1 ); WRITELN( OUTFILE , KOEFSUM2 ); WRITELN( OUTFILE , KOEFSUM3 ); WRITELN( OUTFILE , KOEFSUM ); WRITELN( OUTFILE , AMAX_TOP ); WRITELN( OUTFILE , AMAX ); WRITELN( OUTFILE , Q1 ); WRITELN( OUTFILE , Q2 ); WRITELN( OUTFILE ); END; (* *) (*--------------------------------------------------------------------------*) (* *) (* HAUPTPROGRAM *) (* *) (*--------------------------------------------------------------------------*) (* *) BEGIN IF INHOM THEN M := VRM[-1] ELSE M := 0; FOR I := 0 TO N-1 DO IF VRM[I] > M THEN M := VRM[I]; RADIUS := X_END / OMEGA; (* POTENZEN VON X_END BEREITSTELLEN *) IF ( ( ABS( X_END - 3.141592653589793 ) > 2.0E-14 ) AND ( ABS( X_END - 1.570796326794897 ) > 2.0E-14 ) ) THEN BEGIN MPX_END[0].PREC := 1; MPX_END[0].STAG := 1; MPX_END[0].INT := 0; MPX_END[1].PREC := 1; MPX_END[1].STAG := X_END; MPX_END[1].INT := 0; FOR I := 1 TO KMAX + N DO IF MPX_END[I-1].PREC < KOEFPREC THEN MPX_END[I] := ROUND( MPX_END[I-1] *> X_END , KOEFPREC ) ELSE MPX_END[I] := MPX_END[I-1] *< X_END; END ELSE BEGIN MPX_END[0].PREC := 1; MPX_END[0].STAG := 1; MPX_END[0].INT := 0; MPX_END[1].PREC := 1; MPX_END[1].STAG := RVAL('3.141592653589793115997963468544185161590576171875',1); MPX_END[1].INT := INTVAL( RVAL( '1.224646799147353177E-16' , -1 ) , RVAL( '1.224646799147353177E-16' , +1 ) ); IF ( ABS( X_END - 1.570796326794897 ) <= 2.0E-14 ) THEN BEGIN MPX_END[1].STAG[1] := MPX_END[1].STAG[1] / 2; MPX_END[1].INT := MPX_END[1].INT / 2; END; FOR I := 1 TO KMAX + N DO IF MPX_END[I-1].PREC < KOEFPREC THEN MPX_END[I] := ROUND( MPX_END[I-1] *> MPX_END[1] , KOEFPREC ) ELSE MPX_END[I] := MPX_END[I-1] *< MPX_END[1]; END; (* STARTWERTE VORBESETZEN *) UNTERLAUF := FALSE; RESTGLIED := 0; SKALFAKT := 1; FAK[0] := 1; TIA[0].PREC := 1; TIA[0].STAG := VRY[0]; TIA[0].INT := 0; AMAX := ABS( VRY[0] ); FOR I := 1 TO N - 1 DO BEGIN FAK[I] := FAK[I-1] * I; TIA[I] := ( MPX_END[I] *> VRY[I] ); IF TIA[I].PREC < KOEFPREC THEN TIA[I].PREC := KOEFPREC; TIA[I] := TIA[I] / FAK[I]; TIA[I] := ROUND( TIA[I] , KOEFPREC ); ANEU := ABS_SUP( TIA[I] ) / ( OMEGA ** I ); IF AMAX < ANEU THEN AMAX := ANEU; END; (* BASIS-MULTIPLIKATOREN BERECHNEN *) FOR I := 0 TO N - 1 DO FOR J := 0 TO KMAX DO MULTIP[I,J] := ROUND( TIB[I,J] *> MPX_END[N-I+J] , KOEFPREC ); K := -1; KOEFSUM := 1; WHILE ( ( KOEFSUM >= 1 ) AND ( K < KMAX - N ) ) DO BEGIN (* "VORITERATION" OHNE FEHLERABSCHAETZUNG *) (* KOEFSUM GIBT AN, OB DIE a_k NOCH WACHSEN KOENNEN *) K := K + 1; TIA[K+N].PREC := KOEFPREC; (* K+N-TEN TAYLORKOEFFIZIENTEN BERECHNEN *) IF INHOM THEN TAYKOEFF_INHOM( K ) ELSE TAYKOEFF_HOM( K ); (* MAXIMUM DER TAYLOR-KOEFFIZIENTEN DER LOESUNG ABSCHAETZEN *) ANEU := ABS_SUP( TIA[K+N] ) / ( OMEGA ** ( K + N ) ); IF AMAX < ANEU THEN AMAX := ANEU; (* (K+N+1)-TE PRODUKTE BERECHNEN *) IF K + 1 > PRODINDEX THEN PRODUCTS( K + 1 , PRODINDEX ); (* ABBRUCHKRITERIUM UEBERPRUEFEN, FALLS INDEX HINREICHEND GROSS *) IF K >= N * M THEN BEGIN AMAX_TOP := ABS_SUP( TIA[K-M+1] ) / ( OMEGA ** ( K - M + 1 ) ); FOR I := K - M + 1 TO K + N DO BEGIN ANEU := ABS_SUP( TIA[I] ) / ( OMEGA ** I ); IF AMAX_TOP < ANEU THEN AMAX_TOP := ANEU; END; (* BERUECKSICHTIGUNG VON RUNDUNGSFEHLERN DER OBIGEN OPERATIONEN *) AMAX_TOP := AMAX_TOP * 1.000000000001; (* PROZEDUR KOEFSUMS TESTET REGRESSIONSBEDINGUNG *) KOEFSUMS; END; (* ABBRUCHKRITERIUM PRUEFEN *) (* ZWISCHENERGEBNISSE AUSDRUCKEN *) IF ( K + N <= 23 ) OR ( ( K+N ) MOD 23 = 0 ) THEN BEGIN REIHE[0] := ##( FOR I := 0 TO K + N SUM( TIA[I].INT + FOR J := 1 TO TIA[I].PREC SUM( TIA[I].STAG[J] ) ) ); AUSFILE1( K + N ); END; IF ( K + N ) MOD 23 = 0 THEN IF UNTERLAUF THEN WRITELN( CONSOLE , K+N:3, ' ', TIA[K+N].STAG[1] , ' (skal.)' ) ELSE WRITELN( CONSOLE , K + N : 3 , ' ' , TIA[K+N].STAG[1] ); FLUSH( CONSOLE ); END; (* WHILE *) WRITE( 'Wachstum der Summanden nach ' , K + N : 1 ); WRITELN( ' Summanden beendet.' ); WRITE( OUTFILE , 'Wachstum der Summanden nach ' , K + N : 1 ); WRITELN( OUTFILE , ' Summanden beendet.' ); REIHE[0] := ##( FOR I := 0 TO K + N SUM( TIA[I].INT + FOR J := 1 TO TIA[I].PREC SUM( TIA[I].STAG[J] ) ) ); (* MAXSUMMAND: NUR ZUR SKALIERUNG BEI NUMERISCHEM UEBERLAUF *) MAXSUMMAND := ABS( TIA[K+N].STAG[1] ); (* ITERATION MIT FEHLERABSCHAETZUNG *) REPEAT K := K + 1; TIA[K+N].PREC := KOEFPREC; (* K+N-TEN TAYLORKOEFFIZIENTEN BERECHNEN *) IF INHOM THEN TAYKOEFF_INHOM( K ) ELSE TAYKOEFF_HOM( K ); (* (K+N+1)-TE PRODUKTE BERECHNEN *) IF K + 1 > PRODINDEX THEN PRODUCTS( K + 1 , PRODINDEX ); (* ZWISCHENERGEBNISSE AUSDRUCKEN *) IF ( K + N ) MOD 23 = 0 THEN IF UNTERLAUF THEN WRITELN( CONSOLE, K+N:3, ' ', TIA[K+N].STAG[1], ' (skal.)' ) ELSE WRITELN( CONSOLE , K + N : 3 , ' ' , TIA[K+N].STAG[1] ); FLUSH( CONSOLE ); (* KOEFSUM AKTUALISIEREN *) (* AMAX_TOP_ALT WIRD ZUR STABILITAETSKONTROLLE BENOETIGT *) AMAX_TOP_ALT := AMAX_TOP; AMAX_TOP := ABS_SUP( TIA[K-M+1] ) / ( OMEGA ** ( K - M + 1 ) ); FOR I := K - M + 1 TO K + N DO BEGIN ANEU := ABS_SUP( TIA[I] ) / ( OMEGA ** I ); IF AMAX_TOP < ANEU THEN AMAX_TOP := ANEU; END; (* BERUECKSICHTIGUNG VON RUNDUNGSFEHLERN DER OBIGEN OPERATIONEN *) AMAX_TOP := AMAX_TOP * 1.000000000001; (* PROZEDUR KOEFSUMS TESTET REGRESSIONSBEDINGUNG *) KOEFSUMS; (* ABBRUCHKRITERIUM: *) (* T_IND-te ABLEITUNG MAXIMAL GENAU EINGESCHLOSSEN *) FINISHED := TRUE; IF ( Q < 0 ) OR ( Q > 1 ) THEN FINISHED := FALSE ELSE FOR I := T_IND TO T_IND DO BEGIN (* I-TE ABLEITUNG EINSCHLIESSEN *) REIHE[I] := ##( FOR J := I TO K + N SUM( PROD[J-I,I] * TIA[J].INT + FOR L := 1 TO TIA[J].PREC SUM( PROD[J-I,I] * TIA[J].STAG[L] ) ) ); (* ES WURDE ABER Q = Q(K) BERECHNET, OBWOHL *) (* FUER DAS RESTGLIED Q(K+1) (< Q(K)) GENUEGEN WUERDE *) (* DER EVENTUELLE EINFLUSS DER RUNDUNGSFEHLER IST DADURCH *) (* UEBERKOMPENSIERT *) RESTGLIED := Q *> AMAX *> PROD[K+N+1-T_IND,T_IND] *> ( OMEGA ** ( K + N + 1 - T_IND ) ) *> ( ( 1 + OMEGA ) ** T_IND ) /> ( ( 1 -< OMEGA ) ** ( T_IND + 1 ) ); (* ZWISCHENERGEBNISSE AUSDRUCKEN *) AUSFILE1( K + N ); IREST[I] := INTVAL( - RESTGLIED , RESTGLIED ); IX_END := ##( FOR L := 1 TO MPX_END[I].PREC SUM( MPX_END[I].STAG[L] ) + MPX_END[I].INT ); VIZ[I] := ( REIHE[I] + IREST[I] ) / IX_END; REIHE[I] := REIHE[I] / IX_END; IREST[I] := IREST[I] / IX_END; DURCHMESSER := VIZ[I].SUP -> VIZ[I].INF; IF ( RESTGLIED / ABS( REIHE[I].SUP ) > 1.0E-17 ) AND ( DURCHMESSER > E_ABS ) THEN FINISHED := FALSE; IF AMAX_TOP_ALT < AMAX_TOP THEN BEGIN (* EINSCHLIESSUNGEN WERDEN SCHLECHTER *) (* FORTPFLANZUNG VON AUSLOESCHUNGSFEHLERN *) (* HOEHERE GENAUIGKEIT BENOETIGT *) WRITELN( 'Keine genaue Einschließung erzielbar.' ); WRITELN( 'Das Zahlenformat muss erhöht werden.' ); END; END; IF FINISHED THEN FOR I := 0 TO N - 1 DO BEGIN (* I-TE ABLEITUNG EINSCHLIESSEN *) REIHE[I] := ##( FOR J := I TO K + N SUM( PROD[J-I,I] * TIA[J].INT + FOR L := 1 TO TIA[J].PREC SUM( PROD[J-I,I] * TIA[J].STAG[L] ) ) ); (* ES WURDE ABER Q = Q(K) BERECHNET, OBWOHL *) (* FUER DAS RESTGLIED Q(K+1) (< Q(K)) GENUEGEN WUERDE *) (* DER EVENTUELLE EINFLUSS DER RUNDUNGSFEHLER IST DADURCH *) (* UEBERKOMPENSIERT *) RESTGLIED := Q *> AMAX *> PROD[K+N+1-I,I] *> ( OMEGA ** ( K + N + 1 - I ) ) *> ( ( 1 + OMEGA ) ** I ) /> ( ( 1 -< OMEGA ) ** ( I + 1 ) ); IREST[I] := INTVAL( - RESTGLIED , RESTGLIED ); IX_END := ##( FOR L := 1 TO MPX_END[I].PREC SUM( MPX_END[I].STAG[L] ) + MPX_END[I].INT ); VIZ[I] := ( REIHE[I] + IREST[I] ) / IX_END; REIHE[I] := REIHE[I] / IX_END; IREST[I] := IREST[I] / IX_END; END; UNTIL FINISHED; FOR I := N - 1 DOWNTO 0 DO VIZ[I] := VIZ[I] / SKALFAKT; AUSFILE2( K + N ); WRITELN( 'Einschließung mit ' , K + N : 1 , ' Reihengliedern erhalten.' ); WRITELN; WRITELN( OUTFILE ); WRITELN( OUTFILE ); WRITELN( OUTFILE , 'Einschließung mit ' , K + N : 1 , ' Reihengliedern:' ); WRITELN( OUTFILE ); FOR I := 0 TO N - 1 DO BEGIN WRITE( OUTFILE , 'y^(' , I : 1 , ') (' , X_END : 10 : 9 , ') î ' ); IWRITELN( OUTFILE , VIZ[I] ); END; END; END. (*==========================================================================*) (* *) (* PASCAL-XSC - MODUL LIVP_MPS *) (* *) (* MODUL ZUR LOESUNG DES ANFANGSWERTPROBLEMS ZUR DGL *) (* *) (* y^(n) = \sum_(i=0)^(n-1) p_i(x) y^(i) + p(x), p(x), p_i(x) Polynome *) (* *) (* POTENZREIHENANSATZ: y(x) = \sum_0^infty a_k x^k *) (* LOESUNG MIT VARIABLER TAYLORENTWICKLUNG UND RESTGLIEDABSCHAETZUNG *) (* RECHNUNG MIT ADAPTIVER GENAUIGKEIT *) (* *) (* VERSION FUER RECORD-BASIERTE MPS-ARITHMETIK *) (* *) (*==========================================================================*)