restart;

Mit Hilfe dieser Funktion l\344sst sich einfach zwischen 2 Basen wechseln.als Parameter wird folgendes \374bergeben: 1. Parameter: [ an , . . . , a1 , a0 ] : Der erste Parameter ist eine Liste der Stellen in der Basis1 Achtung!: Im Gegensatz zu den herk\366mmlichen Convert Funktionen von Maple muss diese Liste von Stellen nicht in der umgekehrten Reihenfolge eingegeben werden. Achtung!: Die Stellen m\374ssen immer als Zahl eingegeben werden. Das heisst beispielsweise bei Hexadecimal nicht A eingeben, sondern 10! 2. Parameter: basis1 : ist die Quellbasis, die Basis in welcher die oben angegebene Liste von Stellen steht. 3. Parameter: basis2 : ist die Zielbasis, die Basis, in welcher das Resultat sein sollte.

unassign('swap_list'): unassign('convert_base'):swap_list := proc( list ) local i: return [seq( op(-i,list), i=1..nops(list))]; end proc:convert_base := proc( list, basis1, basis2) local swapped_list_b1, swapped_list_b2, list_b2: swapped_list_b1 := swap_list(list): swapped_list_b2 := convert(swapped_list_b1, base, basis1, basis2): list_b2 := swap_list( swapped_list_b2 ): return list_b2; end proc:

swap_list([1,1,2]);

NiM3JSIiIyIiIkYl

convert_base([1,1,2], 3, 5);

NiM3JCIiIyIiJQ==

restart;

Diese simplen Funktionen berechnen aus dem genauen Wert und dem approximierten Wertden absoluten Fehler und den relativen Fehler. 1. Parameter: z1 : genauer Wert 2. Parameter: z2 : approximierter Wert

unassign('absoluter_fehler'): unassign('relativer_fehler'):absoluter_fehler := proc( z1 , z2 ) local abs_fehler: abs_fehler := evalf(abs( z1 - z2 )): printf("\134t\134t\134t Der Absolute Fehler betr\344gt: %20.10f", abs_fehler); printf("\t\t\t\t\t\t\t\t\t\tbzw.: %20e", abs_fehler); end proc:relativer_fehler := proc( z1, z2 ) local rel_fehler: rel_fehler := evalf( (abs( z1 - z2 ))/(z1) ): printf("\134t\134t\134t Der Relative Fehler betr\344gt: %20.10f", rel_fehler); printf("\t\t\t\t\t\t\t\t\t\tbzw.: %20e", rel_fehler); end proc:

absoluter_fehler(exp(1), 2,47);

Der Absolute Fehler betr\344gt: 0.7182818280 bzw.: 7.182818e-01

relativer_fehler(exp(1), 2.47);

Der Relative Fehler betr\344gt: 0.0913377802 bzw.: 9.133778e-02

restart;

iscont testet ob die Funktion im Intervall stetig ist oder nicht. closed ist optional und bestimmt, ob es ein offenes oder geschlossenes Intervall ist.discont gibt die Stellen von der Funktion aus, wo die Funktion nicht stetig ist.Das x im Funktionsaufruf gibt an, nach welcher Variabel in der Funktion getestet werden muss.

f:=x->signum(x);

NiM+SSJmRzYiZio2I0kieEdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlLUknc2lnbnVtR0YlNiM5JEYlRiVGJQ==

iscont(f(x),x=-1..1,closed);

NiNJJmZhbHNlR0kqcHJvdGVjdGVkR0Yk

discont(f(x),x);

NiM8IyIiIQ==

g:=x->x**2;

NiM+SSJnRzYiZio2I0kieEdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlKiQ5JCIiI0YlRiVGJQ==

iscont(g(x),x=-infinity..infinity);

NiNJJXRydWVHSSpwcm90ZWN0ZWRHRiQ=

discont(g(x),x);

NiM8Ig==

restart;

Diese Funktion testet, ob f(x) an der Stelle x0 stetig ist.

stetig := proc (f, x0) local limit1, limit2; print(plot(f(x),x=x0-10..x0+10,y=f(x0)-10..f(x0)+10)); limit1:=limit(f(x),x=0,left); limit2:=limit(f(x),x=0,right); printf("\t\t\t\t\t\Die Ableitung von links lautet: %20f\n", limit1); printf("\t\t\t\t\t\Die Ableitung von rechts lautet: %20f\n", limit2); if limit1 = limit2 then print("Die Funktion ist stetig an dieser Stelle"); else print("Die Funktion ist NICHT stetig an dieser Stelle"); end if;end proc:;

f:=(x)->signum(x);

NiM+SSJmRzYiZio2I0kieEdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlLUknc2lnbnVtR0YlNiM5JEYlRiVGJQ==

stetig(f,0);

LSUlUExPVEc2Ji0lJ0NVUlZFU0c2JDdobjckJCEjNSIiISQhIiJGLDckJCEzInBtbW0icDBrJiohIzxGLTckJCEzdUtMJDM8WFo9KkYyRi03JCQhM1htbW1UJXAiZSgpRjJGLTckJCEzL25tbSI0bShHJClGMkYtNyQkITNPTEwkM2kuOSF6RjJGLTckJCEzZm1tOy9SPTB2RjJGLTckJCEzaysrXVA4I1w0KEYyRi03JCQhM0ttbTsvc2lxbUYyRi03JCQhM1EqKioqXCh5JHBaaUYyRi03JCQhM2pLTEwkeWFFImVGMkYtNyQkITM8bW1tIj5zJUhhRjJGLTckJCEzXSoqKioqKlwkKjQpKlxGMkYtNyQkITNwKioqKioqXF8mXGMlRjJGLTckJCEzJCkqKioqKipcMWFaVEYyRi03JCQhM0ltbTsvIylbb1BGMkYtNyQkITMlSExMTD1leEokRjJGLTckJCEzbEtMTEwyJGYkSEYyRi03JCQhMyUpKioqKlxQWXgiXCNGMkYtNyQkITNnTExMTDdpKTQjRjJGLTckJCEzbikqKipcUCdwc20iRjJGLTckJCEzPyoqKipcNzRfYzdGMkYtNyQkITNNOkxMJDN4JXojKSEjPUYtNyQkITMoKUhMTDNzJFFNJUZccEYtNyQkITM+KioqKlxpdkZAQUZccEYtNyQkITNcXm9tbTt6cikqISM/Ri03JCQiM0wnPTNGcF55IVJGZnAkIiIiRiw3JCQiM1RBJDNfXVwobzwhIz5GanA3JCQiMz9FZTlUUXJZSkZfcUZqcDckJCIzKSpITDN4InlZXyVGX3FGanA3JCQiM2FQJGUqW29nIUcoRl9xRmpwNyQkIjNeTUwzX05sLjVGXHBGanA3JCQiMy5PJGVrR1JbYiJGXHBGanA3JCQiM2FQTCQzLURnNSNGXHBGanA3JCQiM2NTTGUqWydSM0tGXHBGanA3JCQiM2ZWTExlenc1VkZccEZqcDckJCIzSnRtbW1KK0lpRlxwRmpwNyQkIjMuLisrdiRRI1wiKUZccEZqcDckJCIzJVxMTCRlIipbSDdGMkZqcDckJCIzPisrKytkeGQ7RjJGanA3JCQiM2YrKytEMHh3P0YyRmpwNyQkIjM1LCtdaSZwQFsjRjJGanA3JCQiMysrKyt2Z0hLSEYyRmpwNyQkIjNFbG1tbVp2T0xGMkZqcDckJCIzJjQrKyt2KydvUEYyRmpwNyQkIjNVS0wkZVI8KmZURjJGanA3JCQiM0wtKytdKUh4ZSVGMkZqcDckJCIzIWZtbSJIIW8tKlxGMkZqcDckJCIzWCwrXTdrLjZhRjJGanA3JCQiMyNlbW1tVDlDI2VGMkZqcDckJCIzMyoqKipcaSEqM2BpRjJGanA3JCQiMzxOTExMKnp5bSdGMkZqcDckJCIzKWVMTCQzTjEjNChGMkZqcDckJCIzLHBtO0hZdDd2RjJGanA3JCQiMzctKysreEcqKnlGMkZqcDckJCIzZ3BtbVQ2S1UkKUYyRmpwNyQkIjNxTkxMTGJkUSgpRjJGanA3JCQiM1srK11pYDFoIipGMkZqcDckJCIzQC0rXVA/V2wmKkYyRmpwNyQkIiM1RixGanAtJSZDT0xPUkc2JiUkUkdCRyRGX3dGLiRGLEYuRmV3LSUrQVhFU0xBQkVMU0c2JFEieDYiUSJ5Rmp3LSUlVklFV0c2JDskISQrIkYuRl53Rl94LSUlRk9OVEc2JCUqSEVMVkVUSUNBR0Zfdw==

Die Ableitung von links lautet: -1.000000 Die Ableitung von rechts lautet: 1.000000 NiNRT0RpZX5GdW5rdGlvbn5pc3R+TklDSFR+c3RldGlnfmFufmRpZXNlcn5TdGVsbGU2Ig==

restart;

Mit der Eingabe des Intervals werden mit Hilfe des Intervallschachtelung die Nullstellen berechnet.DAS VERFAHREN KANN NUR REELLE NULLSTELLEN FINDENa UND b M\334SSEN ALS FLOAT DEFINIERT WERDEN (Z.B. 0.0)a : Startwert des Intervallsb : Endwert des IntervallsTOL : Toleranz, die erreicht werden sollN : Maximale Anzahl an Durchl\344ufen (wird verwendet, bei einem endlos Loopf : Funktion, definiert mit f:=x->x**2;

bisect := proc(a,b,TOL,N,f) local aa,bb,p,i; Digits := 50; aa := a; bb := b; p := (a+b)/2; i := 0; printf("Intervallschranke links: %12.10f\tIntervallschranke rechts: %12.20f\n", evalf(aa),evalf(bb)); while(evalf(abs(f(p)))>TOL and i<=N) do i := i+1; if(evalf(f(aa)*f(p))<0)then bb := p; else aa := p; end if; p := (aa+bb)/2; printf("i = %d a = %12.20f b = %12.20f p = %12.20f f(p) := %12.20f\n",i,evalf(aa),evalf(bb),evalf(p),evalf(f(p))); end do; print(p); print(evalf(p)); end proc:

f := (x) -> x^3+4*x^2-10;

NiM+SSJmRzYiZio2I0kieEdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlLCgqJDkkIiIkIiIiKiRGLiIiIyIiJSEjNUYwRiVGJUYl

bisect(1,2,0.0005,20,f);

Intervallschranke links: 1.0000000000 Intervallschranke rechts: 2.00000000000000000000 i = 1 a = 1.00000000000000000000 b = 1.50000000000000000000 p = 1.25000000000000000000 f(p) := -1.79687500000000000000 i = 2 a = 1.25000000000000000000 b = 1.50000000000000000000 p = 1.37500000000000000000 f(p) := 0.16210937500000000000 i = 3 a = 1.25000000000000000000 b = 1.37500000000000000000 p = 1.31250000000000000000 f(p) := -0.84838867187500000000 i = 4 a = 1.31250000000000000000 b = 1.37500000000000000000 p = 1.34375000000000000000 f(p) := -0.35098266601562500000 i = 5 a = 1.34375000000000000000 b = 1.37500000000000000000 p = 1.35937500000000000000 f(p) := -0.09640884399414062500 i = 6 a = 1.35937500000000000000 b = 1.37500000000000000000 p = 1.36718750000000000000 f(p) := 0.03235578536987304688 i = 7 a = 1.35937500000000000000 b = 1.36718750000000000000 p = 1.36328125000000000000 f(p) := -0.03214997053146362305 i = 8 a = 1.36328125000000000000 b = 1.36718750000000000000 p = 1.36523437500000000000 f(p) := 0.00007202476263046265 NiMjIiQqcCIkNyY=NiMkIlMrKysrKysrKysrKysrKysrKysrK3ZWQmw4ISNc

restart;

Mit der Eingabe eines Startwertes werden mit Hilfe des Newton-Verfahrens die Nullstellen berechnet. DAS VERFAHREN KANN NUR REELLE NULLSTELLEN FINDENp0 MUSS ALS FLOAT DEFINIERT SEIN (Z.B. 0.0)p0 : erster Punkt, an den die Tangente gelegt wird.TOL : Toleranz, die erreicht werden sollN : Maximale Anzahl an Durchl\344ufen (wird verwendet, bei einem endlos Loopf : Funktion, definiert mit f:=x->x**2;

newton := proc(p0,TOL,N,f) local converging,fprime,i,pold,p; Digits := 50; fprime := (x) -> D(f)(x); converging := true; i := 0; pold := p0; printf("Startwert: %12.20f\n", evalf(p0)); while converging do i := i+1; p := pold-f(pold)/fprime(pold); printf("i = %d p = %12.20f f(p) := %12.20f\n",i,p,f(p)); pold := p; converging := evalf(abs(f(p)))>TOL and i<N; end do; print(pold); print(evalf(pold)); end proc:

f:=(x)->x**3+4*x**2-10;

NiM+SSJmRzYiZio2I0kieEdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlLCgqJDkkIiIkIiIiKiRGLiIiIyIiJSEjNUYwRiVGJUYl

newton(1,10**(-5),20,f);

Startwert: 1.00000000000000000000 i = 1 p = 1.45454545454545454545 f(p) := 1.54019534184823441022 i = 2 p = 1.36890040106951871658 f(p) := 0.06071968863994171809 i = 3 p = 1.36523660020211594624 f(p) := 0.00010877061042579891 i = 4 p = 1.36523001343536660976 f(p) := 0.00000000035123610110 NiMjIkdoIj5LL1onSCJIYkFBeWFNKT1IPiUqIkdjZVI3RCopXEgweU9eRkZGdlQqKm8=NiMkIlNuaThBRjAoRydRUVJ1bnhiKDRtT05NLElfTyIhI1w=

restart;

Mit der Eingabe von 3 Werten werden mit Hilfe des M\374ller-Verfahrens die Nullstellen berechnet.DAS VERFAHREN KANN AUCH KOMPLEXE NULLSTELLEN FINDENp0in, p1in UND p2in M\334SSEN ALS FLOAT DEFINIERT WERDEN (Z.B. 0.0)p0in : erster x-Wertp1in : zweiter x-Wertp2in : dritter x-WertTOL : Toleranz, die erreicht werden sollN : Maximale Anzahl an Durchl\344ufen (wird verwendet, bei einem endlos Loopf : Funktion, definiert mit f:=x->x**2;

mueller := proc (p0in,p1in,p2in,TOL,N,f) local p0,p1,p2,n,converging,det,a,b,c,p; Digits := 50; p0 := p0in; p1 := p1in; p2 := p2in; printf("p0 = %12.20f p1 = %12.20f p2 = %12.20f\n",p0,p1,p2); n := 2; converging := true; while converging do n := n+1; det := (p0-p2)*(p1-p2)*(p0-p1); a := ((p1-p2)*(f(p0)-f(p2))-(p0-p2)*(f(p1)-f(p2)))/det; b := ((p0-p2)^2*(f(p1)-f(p2))-(p1-p2)^2*(f(p0)-f(p2)))/det; c := f(p2); p := evalf(p2-2*c/(b+(abs(evalf(Re(b)))/evalf(Re(b)))*sqrt(b^2-4*a*c))); printf("n = %d p = %12.20a f(p) = %a\n",n,p,f(p)); converging := abs(evalf(f(p)))>TOL and n<N; p0 := p1; p1 := p2; p2 := p; end do; print(evalf(p)); end proc:

f:=(x)->16*x**4-40*x**3+5*x**2+20*x+6;

NiM+SSJmRzYiZio2I0kieEdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlLCwqJDkkIiIlIiM7KiRGLiIiJCEjUyokRi4iIiMiIiZGLiIjPyIiJyIiIkYlRiVGJQ==

mueller(0.5,-0.5,0,0.00001,20,f);

p0 = 0.50000000000000000000 p1 = -0.50000000000000000000 p2 = 0.00000000000000000000 n = 3 p = -.555555555555555555 f(p) = -29.400701112635269013869836915104404816338972717574-3.898724711764806302155292613140765949154369877732*I n = 4 p = -.130731183150713007 f(p) = 3.0733838452095444042611946013548803048222401673705-2.6295176879783921124333716865655499258171529204591*I n = 5 p = -.231289053757210118 f(p) = 1.9033247133120719764500332069308353054817200899328+.93524770947281091929159666961126842955656736693478*I n = 6 p = -.315071312811495787 f(p) = .8449875028574559682631382605988613155016224102687+.4598886169853518635876149898336476913564742213407*I n = 7 p = -.366513762674778379 f(p) = -.1738923467600027079166659763763543096647432078692-.1875492944220974161211437045223282498253190074392*I n = 8 p = -.355735171228669758 f(p) = .33596153257496637869870071290635995540530708870e-2+.58775577602647207438813630044982470947046120257e-2*I n = 9 p = -.356060938521309358 f(p) = .53246914418689636376482249897313867158284855e-5+.153764248023111468495140884281327029909283460e-4*I n = 10 p = -.356061761736601532 f(p) = -.681020949279284241600913254080354795220e-10+.2242212844258853897424761474828814720718e-9*I NiNeJCQhU3RRPidvNXMoZSdcaCYpRzUiPiVHYCxtdGg8MWMkISNdJCJTPnYqKjM0eFVTLEdVKClIXiwoXE53biZHUWVGO0Ym

mueller(0.5,1.0,1.5,0.00001,20,f);

p0 = 0.50000000000000000000 p1 = 1.00000000000000000000 p2 = 1.50000000000000000000 n = 3 p = 1.287854737551756876 f(p) = -1.376274560795554110952686602778825932423123288318 n = 4 p = 1.237458750361336731 f(p) = .126945398693346955430546602757849028826339662719 n = 5 p = 1.241604514056309098 f(p) = .2193408761085774908280794108878168906719748854e-2 n = 6 p = 1.241677463730854310 f(p) = -.570403633529792512392224646049426295256949e-6 NiMkIlNUS2hLci4sQVAvO1dtL1ozSmEzdGp1blQ3ISNc

mueller(2.5,2.0,2.25,0.00001,20,f);

p0 = 2.50000000000000000000 p1 = 2.00000000000000000000 p2 = 2.25000000000000000000 n = 3 p = 1.960592288479807965 f(p) = -.611309954321339353293125972872522233225549582937 n = 4 p = 1.970563602034442277 f(p) = .7455498762433396238554753952073282479657787062e-2 n = 5 p = 1.970446538522636680 f(p) = .29160944495189546060048653406140083223191378e-4 n = 6 p = 1.970446078730601581 f(p) = .45766600801991895244639708530774250408e-10 NiMkIlN3KVIjeU9lYG8oZmhlJClHbEIiZSwxdHlnV3E+ISNc

solve(f(x),x);

NiYtSSdSb290T2ZHNiRJKnByb3RlY3RlZEdGJkkoX3N5c2xpYkc2IjYkLCwqJEkjX1pHRigiIiUiIzsqJEYsIiIkISNTKiRGLCIiIyIiJkYsIiM/IiInIiIiL0kmaW5kZXhHRiVGNy1GJDYkRiovRjlGMy1GJDYkRiovRjlGMC1GJDYkRiovRjlGLQ==

evalf(%);

NiYkIitYdW5UNyEiKiQiK3pnV3E+RiVeJCQhKzx3aGdOISM1JCIrSFFlRjtGK14kRikkIStIUWVGO0Yr

restart;

Nach der Definition der Zahlendarstellung werden Epsilon, Precision, der minimale Wert (absolut) und der maximale Wert (absolut).basis : Basis, in der die Zahl dargestellt wirdexponent : L\344nge des Exponentene_min : kleinster Exponente_max : gr\366sster Exponentcharakteristika : Charakteristikamanisse : L\344nge der Mantisse

eigenschaften_computerdarstellung := proc (b, e, e_min, e_max, c, m) local epsilon, precision, i; epsilon := evalf(b**(-m)); precision := evalf(b**m); i:=0; while precision > 1 do precision := precision / 10; i := i+1; end do; printf("\t\t\t\t\tDas Epsilon (Maschinengenauigkeit) lautet: %40e\n", epsilon); printf("\t\t\t\t\tDie Precision (Anzahl signifikante Stellen) lautet: %25d\n",i); printf("\t\t\t\t\tDie minimale darstellbare Zahl lautet: %40e\n", (b**e_min)*(b**(-(m-1)))); printf("\t\t\t\t\tDie maximale darstellbare Zahl lautet: %40e\n", 2**e_max+1); end proc:

eigenschaften_computerdarstellung(2,11,-1023,1024,1023,52);

Das Epsilon (Maschinengenauigkeit) lautet: 2.220446e-16 Die Precision (Anzahl signifikante Stellen) lautet: 16 Die minimale darstellbare Zahl lautet: 4.940656e-324 Die maximale darstellbare Zahl lautet: 1.797693e+308

restart;

Die Funktion wandelt eine Float-number in die Computerdarstellung mit den gegebenen Eigenschaften um.Die Ausgabe erfolgt als String mit folgendem Aufbau: "Vorzeichen Exponent Mantisse"float-numer : umzuwandelnde Zahlmantissa-length : L\344nge der Mantisseexponent-length : L\344nge des Exponentencharakteristika : Charakteristika

decimal_to_mantissa:=proc(s,p,e,c) local exp,exponent,E,f,L,i,tmp,t,mantisse,vorz,result; with(StringTools): if s < 0 then vorz:="1"; else vorz:="0"; end if; Digits:= p*20; t:=abs(s)+0.0; #print(t); t:=convert(t,binary); #print(t); f:=t; t:=SFloatMantissa(t); exp:=0; if f < 1 then while f < 1 do f:=f*10; exp:=exp -1; end do; elif f > 1 then while f > 1 do f:=f/10; exp:=exp +1; end do; exp:=(exp-1); end if; exp:=exp+c; printf("\t\t\t\t\tDer Exponent hat mit der Charakteristika den Wert = %d\n", exp); exp:=convert(exp,binary); printf("\134t\134t\134t\134t\134tDer Exponent hat den bin\344ren Wert = %d\134n", exp); #print(t); L := []; E:=[]; for i from 1 while not tmp="" do tmp:= substring(convert(exp,string),i); #print(tmp); E := [parse(tmp),op(E)]; end do; #print(E); tmp:=" "; for i from 1 while not tmp="" do tmp:= substring(convert(t,string),i); L := [parse(tmp),op(L)]; end do; while nops(E)<e do E := [op(E),0]; end do; if nops(L) <= p+1 then #print ("this"); while nops(L)<=p+1 do L := [0,op(L)]; end do; else while not nops(L)=p+2 do L:=subsop(1=NULL,L); end do; L := subsop(2=L[1]+L[2],L); #L := subsop(1=NULL,L); L:=convert(L,base,2,2); end if; #print(L); L := subsop(nops(L)=NULL,L); i:=1; mantisse:=""; while not nops(L)=i do i:=i+1; mantisse:=cat(convert(L[i],string),mantisse); end do; i:=0; exponent:=""; while not nops(E)=i do i:=i+1; exponent:=cat(convert(E[i],string),exponent); #print(exponent); end do; result:= cat(cat(vorz," "),exponent); result:= cat(cat(result," "),mantisse); #print(result); return result; end proc:

decimal_to_mantissa(-0.08038330078,10,5,15);

Warning, the assigned name Group now has a global binding

Der Exponent hat mit der Charakteristika den Wert = 11 Der Exponent hat den bin\344ren Wert = 1011 NiNRMzF+MDEwMTF+MDEwMDEwMDEwMTYi

restart;

Die Funktion wandelt einen String ("Vorzeichen Exponent Mantisse", immer ein SPACE dazwischen) in die dezimale Darstellung um.Die Ausgabe erfolgt als Float-Wert. String : Zahl in Computerdarstellung mit SPACES getrennt (im Beispiel _) z.B "1_01011_0100100101"mantissa-length : L\344nge der Mantisseexponent-length : L\344nge des Exponentencharakteristika : Charakteristika

mantissa_To_decimal:=proc(s,p,e,c) local exp,exponent,E,f,L,i,tmp,t,mantisse,vorz,result; with(StringTools): E:=[]; L:=[1]; #print("hallo"); vorz:=(-1)**parse(substring(s,1)); for i from 3 to e+2 do tmp:= substring(s,i); #print(tmp); E := [parse(tmp),op(E)]; end do; #print(E); E:=convert(E,base,2,10); i:=0; exponent:=""; #print("hallo"); while not nops(E)=i do i:=i+1; exponent:=cat(convert(E[i],string),exponent); #print(exponent); end do; exponent:=parse(exponent); for i from e+3 to p+e+3 do tmp:= substring(s,i); #print(tmp); L := [parse(tmp),op(L)]; end do; #print(L); L:=convert(L,base,2,10); i:=0; mantisse:=""; while not nops(L)=i do i:=i+1; mantisse:=cat(convert(L[i],string),mantisse); #print(exponent); end do; mantisse:=parse(mantisse); result:=vorz; result:=cat(result,"*"); result:=cat(result,mantisse); result:=cat(result,"*2**("); result:=cat(result,exponent-p); result:=cat(result,"-"); result:=cat(result,c); result:=cat(result,")"); print("Vorzeichen * Mantisse * Basis ^ (Exponent - Charakteristika)"); print(result); return mantisse*2**(exponent-p-c)*vorz; end proc:

evalf(mantissa_To_decimal("1 01011 0100100101",10,5,15));

NiNRZ25Wb3J6ZWljaGVufip+TWFudGlzc2V+Kn5CYXNpc35efihFeHBvbmVudH4tfkNoYXJha3RlcmlzdGlrYSk2Ig==NiNJMi0xKjEzMTcqMioqKDEtMTUpRzYiNiMkISt5K0xRISkhIzY=

restart;

Diese Funktionen packen und entpacken eine Liste von Werten zu einer bestimmten Basisund einer angegebenen Blockgr\366sse. pack_sequence( list, basis, blockgr\366sse ): packt die 'list' in eine neue liste mit der Basis 'basis' mit Blockgr\366sse 'blockgr\366sse'. unpack_sequence( list, basis, blockgr\366sse ): entpackt die 'list' wieder von 'basis' ins 10er System.

pack_sequence := proc(list, basis, block) local blockcounter, powercounter, newlist, i1, newlistelement: newlist := []: if (nops(list) mod block) <> 0 then printf("\134t\134tSorry, aber die list kann nicht in %der Bl\366cke gepackt werden.\134n", block); printf("\t\tDie Anzahl Listenelemente ist kein vielfaches von %d!\n", block); return; end if: for blockcounter from 1 by block to nops(list) do newlistelement := 0: for i1 from blockcounter to (blockcounter+block-1) do newlistelement := newlistelement + (op(i1,list) * basis^(i1-blockcounter)): end do: newlist := [ seq( op(i1,newlist) , i1=1..(nops(newlist))), newlistelement]: end do: end proc:unpack_sequence := proc(list, basis, block) local blockcounter, newlistelements, fillupblock, resultlist: resultlist := []: for blockcounter from 1 to nops(list) do newlistelements := convert([op(blockcounter, list)], base, 10, basis): for fillupblock from nops(newlistelements) to (block-1) do newlistelements := [ seq( op(i, newlistelements), i=1..nops(newlistelements)), 0 ]: end do: resultlist := [ seq(op(i1, resultlist), i1=1..nops(resultlist)), seq( op(i2, newlistelements), i2=1..nops(newlistelements))]: end do: end proc:

pack_sequence([0,0,0,0,1,0,0,0,0,1,0,0], 2, 4);

NiM3JSIiISIiIiIiIw==

unpack_sequence([0,1,2],2,4);

NiM3LiIiIUYkRiRGJCIiIkYkRiRGJEYkRiVGJEYk

pack_sequence([101,37,135,213,254], 256, 5);

NiM3IyIuRHI0L1g0Ig==

unpack_sequence(%,256,5);

NiM3JyIkLCIiI1AiJE4iIiQ4IyIkYSM=