bsh: Gleitkomma-Arithmetik nun implementiert

16/08/2016 - 21:52 von Helmut Schellong | Report spam
Wie vor etwa zwei Wochen angekündigt.
http://www.schellong.de/htm/bshmnk.htm#bshK
http://www.schellong.de/txt/version.txt

f= acosh(f) f= acos(f) f= asinh(f)
f= asin(f) f= atan2(f,f) f= atanh(f)
f= atan(f) f= avogadro() f= boltzmann()
f= c() f= cbrt(f) f= ceil(f)
i= constants() f= copysign(f,f) f= cosh(f)
f= cos(f) f= degtorad(f) f= e()
f= earthacc() f= ec() f= eps0()
f= epsilon() f= erfc(f) f= erf(f)
f= exp2(f) f= exp(f) f= expm1(f)
f= fabs(f) f= factorial(i) f= faraday()
f= fdim(f,f) f= floor(f) f= fma(f,f,f)
f= fmax(f,f) f= fmin(f,f) f= fmod(f,f)
f= frexp(f,$) i= functions() i= getround()
f= goldenratio() f= gravity() f= hypot(f,f)
f= klitzing() f= ldexp(f,i) f= lgamma(f)
i= llrint(f) i= llround(f) f= log10(f)
f= log1p(f) f= log2(f) f= logb(f)
f= log(f) f= modf(f,$) f= mue0()
f= nan() f= nchoosek(f,f) f= nearbyint(f)
f= nextafter(f,f) f= nexttoward(f,f) f= pi()
f= pi2() f= planck() f= plancke()
f= pow(f,f) f= quaequ3p(f,f,f) f= quaequ3m(f,f,f)
f= quaequ2p(f,f) f= quaequ2m(f,f) f= radtodeg(f)
f= remainder(f,f) f= remquo(f,f,$) f= reciprocal(f)
f= rint(f) f= root(f,f) f= round(f)
f= rpar2(f,f) f= rpar3(f,f,f) f= scalbln(f,i)
i= setround(i) f= sinh(f) f= sin(f)
f= sqrt2() f= sqrt3() f= sqrt(f)
f= tanh(f) f= tan(f) f= tgamma(f)
f= trunc(f) f= z0()

Neue Operatoren: # ** ::
(:: unàr und binàr)

Drei Steuervariablen: ARITH_FMT ARITH_EXP3 ARITH_DEG

long double

Ich werde sogleich ein Skript damit schreiben.
Das liefert gewünschte Parallelwiderstandswerte aus 1 bis 3 Werten.
Mit Toleranzwahl und gegebener Wertemenge.

Vollversionen für FreeBSD und Linux stehen zum Download bereit (amd64).
Windows64 wird noch dauern, da 23 Funktionen fehlen.

Das wird wohl die letzte große Erweiterung der bsh sein.



Mit freundlichen Grüßen
Helmut Schellong var@schellong.biz
www.schellong.de www.schellong.com www.schellong.biz
http://www.schellong.de/c.htm
 

Lesen sie die antworten

#1 Helmut Schellong
20/08/2016 - 16:45 | Warnen spam
On 08/16/16 21:52, Helmut Schellong wrote:
Wie vor etwa zwei Wochen angekündigt.


[...]
Ich werde sogleich ein Skript damit schreiben.
Das liefert gewünschte Parallelwiderstandswerte aus 1 bis 3 Werten.
Mit Toleranzwahl und gegebener Wertemenge.



Wie angekündigt:
http://www.schellong.de/htm/rpar.bsh.html

Diverse Ausgaben des Skripts:
A4] rpar.bsh
Startwert-Faktor: 10.0
Puffergroesse: 2880
Puffergroesse: 144 Eintràge
Eintràge: 121
Pufferwerte gelöscht: 1
Eintràge: 120

Startwert.0 Endwert=1e6
Reiheâ4 Zielwert-Toleranz=0.3
Wahl E6 : e6
Wahl E12 : e12
Wahl E24 : e24
Wahl E48 : e48
Zeilen max: z # [12]
Toleranz : t # (t 0.5)
Zielwert : zahl (123 12.3 12e3 ...)
Beenden : E
: 12.5

0 : 12.5 : 12.5 = 15 | 75
583 : 12.5 : 12.5072886 = 13 | 330

0 : 12.5 : 12.5 = 30 | 30 | 75
0 : 12.5 : 12.5 = 16 | 75 | 240
0 : 12.5 : 12.5 = 24 | 30 | 200
0 : 12.5 : 12.5 = 15 | 150 | 150
0 : 12.5 : 12.5 = 15 | 120 | 200
0 : 12.5 : 12.5 = 15 | 100 | 300
14 : 12.5 : 12.4998283 = 15 | 75 | 910000
15 : 12.5 : 12.5001821 = 13 | 330 | 22000
15 : 12.5 : 12.4998095 = 15 | 75 | 820000
17 : 12.5 : 12.4997917 = 15 | 75 | 750000
18 : 12.5 : 12.4997702 = 15 | 75 | 680000
20 : 12.5 : 12.499748 = 15 | 75 | 620000

Startwert.0 Endwert=1e6
Reiheâ4 Zielwert-Toleranz=0.3
Wahl E6 : e6
Wahl E12 : e12
Wahl E24 : e24
Wahl E48 : e48
Zeilen max: z # [12]
Toleranz : t # (t 0.5)
Zielwert : zahl (123 12.3 12e3 ...)
Beenden : E
: _
E24
1761 : 2534 : 2538.46154 = 3300 | 11000
1992 : 2534 : 2539.04762 = 4300 | 6200
2558 : 2534 : 2540.4814 = 2700 | 43000

24 : 2534 : 2534.05995 = 6200 | 7500 | 10000
64 : 2534 : 2534.16149 = 3000 | 24000 | 51000
67 : 2534 : 2533.83132 = 3300 | 13000 | 68000
96 : 2534 : 2533.75777 = 4700 | 5600 | 300000
112 : 2534 : 2533.71572 = 2700 | 47000 | 330000
124 : 2534 : 2534.31373 = 4700 | 11000 | 11000
151 : 2534 : 2533.61656 = 2700 | 75000 | 91000
162 : 2534 : 2533.58925 = 3300 | 20000 | 24000
162 : 2534 : 2533.58925 = 3300 | 12000 | 120000
223 : 2534 : 2533.43523 = 5100 | 5100 | 390000
233 : 2534 : 2533.40879 = 2700 | 43000 | 910000
277 : 2534 : 2534.70218 = 2700 | 51000 | 220000
E6
1308 : 2534 : 2537.31343 = 6800 | 6800 | 10000
1761 : 2534 : 2538.46154 = 3300 | 22000 | 22000
E24
0 : 9 : 9.0 = 18 | 18
0 : 9 : 9.0 = 12 | 36
1100 : 9 : 9.00990099 = 10 | 91

0 : 9 : 9.0 = 27 | 27 | 27
0 : 9 : 9.0 = 24 | 24 | 36
0 : 9 : 9.0 = 20 | 30 | 36
0 : 9 : 9.0 = 18 | 36 | 36
0 : 9 : 9.0 = 18 | 20 | 180
0 : 9 : 9.0 = 15 | 24 | 360
0 : 9 : 9.0 = 10 | 120 | 360
0 : 9 : 9.0 = 10 | 180 | 180
1 : 9 : 9.00001206 = 10 | 91 | 8200
10 : 9 : 8.99991099 = 12 | 36 | 910000
10 : 9 : 8.99991099 = 18 | 18 | 910000
11 : 9 : 8.99990122 = 18 | 18 | 820000
E24
0 : 8.4 : 8.4 = 12 | 56 | 56
28 : 8.4 : 8.40023497 = 13 | 24 | 2200
67 : 8.4 : 8.39944004 = 16 | 18 | 1000
81 : 8.4 : 8.39932127 = 11 | 36 | 2700
190 : 8.4 : 8.39840637 = 12 | 51 | 62
230 : 8.4 : 8.40193499 = 11 | 36 | 3000
244 : 8.4 : 8.39795172 = 10 | 56 | 820
346 : 8.4 : 8.4029087 = 13 | 24 | 2400
349 : 8.4 : 8.39707079 = 16 | 30 | 43
354 : 8.4 : 8.39702874 = 13 | 24 | 2000
364 : 8.4 : 8.39694656 = 10 | 100 | 110
465 : 8.4 : 8.40390879 = 12 | 30 | 430
0.5% Damit nun auch 2 Werte:
3040 : 8.4 : 8.42553191 = 11 | 36
3861 : 8.4 : 8.43243243 = 13 | 24
4684 : 8.4 : 8.36065574 = 10 | 51
=
Ich finde die Ausgaben interessant.
Bei Verwendung E24 findet man fast immer einen beliebigen Zielwert
durch Parallelschaltung von nur zwei E-Reihen-Werten.
Oft ohne Abweichung vom gewünschten Zielwert.

Es ist auch erkennbar, daß eine Parallelschaltung von mehr als
3 Werten nicht nötig ist.
Reihenschaltung ist weit unterlegen.

Bei kleinen Zielwerten làuft das Skript maximal lange.
Bei mir etwa 10 Sekunden.
Das liegt daran, daß bis etwa 1800000 Rechendurchlàufe gemacht werden.
Bei größeren Werten vergeht z.B. nur 1 Sekunde.
(Zwischen 120^3 und 50^3 besteht ein gewaltiger Unterschied.)

Der Wert links ist die Abweichung in ppm, 3000 entspricht der
Default-Toleranz von +-0.3 %.

Das Skript unternimmt sehr viele Prüfungen der Datenbasis, die die
Grundlage aller Berechnungen ist.
Das ist nachlesbar an: Err "Fehlertext"

Err "Falsche E-Reihe: E$E"
Err "Startwert<1: $Beg"
Err "Startwert>=Endwert: $Beg $End"
Err "Falsche Anzahl Werte $er: $a"
Err "$er-Wert < 1: $r"
Err "$er-Wert nicht streng monoton steigend: $r"
Err "$er-Wert-Faktor vom Vorwert her unpassend: $r/$r0"
Err "Endwert unpassend: $End"
Err "$er-Wert < 1: $r"
Err "Startwert unpassend: $Beg"

Variable 'Del' gibt an, welche Werte nicht (mehr) Komponenten
der Parallelschaltungen sein dürfen.

Im Skript ist
GetRpar "$1" | sortl -fn1,n2 | {
while read ap ppm - ziel - val - pr
...
}
zu sehen.

In einer Pipe-Kette der bsh können also auch interne
Kommandos, und sogar Shell-Funktionen stehen.
Das ging damals auch unter (MS-)DOS.
Es wird erkennbar, *warum* ich die Pipes mittels Dateiverwendung
(in Voreinstellung) implementierte, und welche immensen Vorteile
das hat.

Ich bin màchtig zufrieden, daß bsh nun auch Gleitkomma kann.
Ich habe das nicht selten vermißt, und mußte deshalb jeweils
wenig zufriedenstellend frickeln.



Mit freundlichen Grüßen
Helmut Schellong
www.schellong.de www.schellong.com www.schellong.biz
http://www.schellong.de/c.htm

Ähnliche fragen