Und wieder etwas schlauer geworden - danke!
Abt. EaR 14
=========
Mit welcher Tastenkombination kann man in WordPad ein MS-Paint-Bild malen und einbinden?
Und wieder etwas schlauer geworden - danke!
Abt. EaR 14
=========
Mit welcher Tastenkombination kann man in WordPad ein MS-Paint-Bild malen und einbinden?
Lösung zu EaR 14: STRG+D
--------------------------
Die Tabelle im Spoiler enthält Tastenkombinationen für die Arbeit mit WordPad.
WordPad Tastaturkürzel
======================
Strg+N ... Ein neues Dokument erstellen
Strg+O ... Öffnen eines vorhandenen Dokuments
Strg+S ... Änderungen an einem Dokument speichern
F12 ...... Speichern Sie das Dokument als neue Datei.
Strg+P ... Ein Dokument drucken
Alt+F4 ... WordPad schließen
Strg+Z ... Eine Änderung rückgängig machen
Strg+Y ... Eine Änderung wiederholen
Strg+A ... Das gesamte Dokument auswählen
Strg+X ... Eine Auswahl ausschneiden
Strg+C ... Kopieren einer Auswahl in die Zwischenablage
Strg+V ... Eine Auswahl aus der Zwischenablage einfügen
Strg+B ... Markierten Text fett setzen
Strg+I ... Ausgewählten Text kursiv darstellen
Strg+U ... Markierten Text unterstreichen
Strg+=== . Markierten Text tiefgestellt machen
Strg+Umschalt+== Markierten Text hochstellen
Strg+L ... Text links ausrichten
Strg+E ... Textmitte ausrichten
Strg+R ... Text rechtsbündig ausrichten
Strg+J ... Text ausrichten
Strg+1 ... Einzelzeilenabstand einstellen
Strg+2 ... Doppelten Zeilenabstand einstellen
Strg+5 ... Zeilenabstand auf 1,5 einstellen
Strg+Umschalt+> .Schriftgröße vergrößern
Strg+Umschalt+< .Verkleinern der Schriftgröße
Strg+Shift+A ... Ändernt die Zeichen alle Großbuchstaben.
Strg+Shift+L ... Ändern des Aufzählungszeichens
Strg+D ... Einfügen einer Microsoft Paint Zeichnung
Strg+F ... Text in einem Dokument suchen
F3 ....... Suchen Sie die nächste Instanz des Textes im Dialogfenster Suchen.
Strg+H ... Text in einem Dokument ersetzen
Strg+Linkspfeil ....... Bewegen Sie den Cursor ein Wort nach links.
Strg+Rechtspfeil ...... Bewegen Sie den Cursor ein Wort nach rechts.
Strg+Pfeil_nach_oben .. Bewegen Sie den Cursor auf die Zeile über der Zeile.
Strg+Pfeil_nach_unten . Bewegen Sie den Cursor auf die folgende Zeile
Strg+Home ... An den Anfang des Dokuments springen
Strg+Ende ... An das Ende des Dokuments springen
Strg+Seite_nach_oben ... Eine Seite nach oben blättern
Strg+Seite_nach_unten .. Eine Seite nach unten blättern
Strg+Löschen ... Das nächste Wort löschen
F10 ............ Keytips anzeigen
Umschalt+F10 ... Zeigt das aktuelle Kontextmenü an.
F1 .............. WordPad-Hilfe öffnen
Abt. Verlegenheitslösung
==================
Nachdem die PTB Braunschweig die Atomzeitserver offenbar etwas umgestellt hat, funktionieren einige Programme nicht mehr. Da es aber Branchenservices und Fachgeschäfte mit Atomzeitangaben gibt, ist die folgende Verlegenheitslösung entstanden - Achtung, in nachstehender Form vor allem für Österreich gültig! Aber auf Google kann man sicher Dienste finden, die auf das jeweilige Land Bezug nehmen.
Gruss
WindowTitle "Uhrzeit und Datum":WindowStyle 24:Window 100,100 - 200,100
cls:font 2:declare c$,url$,OnString$,ldl&,lon&,zeit$,datm$,in&,Tag$
url$="https://www.zeitzonen.de/oesterreich.html":print "\n zeitzonen.de ..."
@downloadfile(url$):while %Loading:waitinput 333:endwhile:ldl&=&Bytesread
CLS':print "\n ";ldl&;" Byte\n":OnString$="time clock":lon&=len(OnString$)
in&=instr(OnString$,$Download):if in&<=0:print " Zeit nicht gefunden!"
else :zeit$=mid$($Download,in&+lon&+2,8):endif
OnString$="<span class="+chr$(34)+"weekday"+chr$(34)+">"
lon&=len(OnString$):in&=instr(OnString$,$Download)
if in&<=0:print " Tag nicht gefunden!":else :Tag$=mid$($Download,in&+lon&,2)
endif:in&=instr(chr$(34)+"date"+chr$(34),$Download)
if in&<=0:print "Datum nicht gefunden!"
else :Datm$=mid$($Download,in&+7,10):endif
print "\n ";Tag$;" ";Datm$;" ";Zeit$:waitinput 6000:End
Alles anzeigen
Abt. Interessante Links
===============
Unglaubliche Effekte in Video- und Fotografie mittels Bewegungs- und Stil-kopierender Neuronaler Netze (Youtube-Link)
Abt. Parametrierte Figuren
====================
Die sog. Superformel (Youtube, engl.) erzeugt bei geeigneter Wahl der Parameter recht interessante Figuren. Für Bildschirmschoner ist das aber zuwenig - da will man Bewegung. Doch auch diese wird irgendwann langweilig, wie das nachstehende Machwerk als abschreckendes Beispiel zeigt.
Gruss
P.S. Ich trauere immer noch dem alten DOS-Bildschirmschoner Dazzle nach. Nun habe ich ihn wenigstens als Youtube-Video wiedergefunden: Nostalgie pur!
WindowTitle "Figuren mittels Superformel erzeugen"
WindowStyle 24:Cls rgb(0,0,0):ShowMax
var xh&=width(%hwnd)\2:var yh&=height(%hwnd)\2:randomize:font 2
Proc Superformel 'liefert Radius(phi!,...)
parameters phi!,Symmetrie!,Form1!,Form2!,Form3!,xHalbachse!,yHalbachse!
casenot xHalbachse!*yHalbachse!:return 0
var Winkel!=Symmetrie!*phi!*0.25
'r! = (abs(cos(Winkel!)/xHalbachse!)^Form2!+abs(sin(Winkel!)/yHalbachse!)^Form3!)^(-1/Form1!)
var co!=cos(Winkel!):var si!=sin(Winkel!)
var r!=0:case co!<>0:r!=abs(co!/xHalbachse!)^Form2!
case si!<>0:r!=r!+abs(sin(Winkel!)/yHalbachse!)^Form3!
:if r!>0:r! = r!^(-1/Form1!):else r!=0:endif
return r!
EndProc
:Proc To_xy :parameters r!,phi!:x!=r!*cos(phi!):y!=r!*sin(phi!):endproc
:Proc rPhi :parameters x!,y!:r!=sqrt(sqr(x!)+sqr(y!)):phi!=ArcTan4(x!,y!):endproc
Proc ArcTan4 :parameters x!,y!:var pi!=3.1415926535897932:var w!=0
if x!=0:if y!>0:w!=pi!*0.5:elseif y!<0:w!=pi!*1.5:else :w!=0:endif :return w!:elseif x!>0
if y!=0:w!=0:return w!:elseif y!>0:if x!>y!:w!=arctan(y!/x!):else :w!=pi!/2-arctan(x!/y!):endif
return w!:else :if x!<-y!:w!=pi!*1.5+arctan(x!/-y!):else :w!=2*pi!-arctan(-y!/x!):endif :return w!
endif :else :if y!>0:if x!>-y!:w!=pi!/2+arctan(-x!/y!):return w!:else :w!=pi!-arctan(y!/-x!)
return w!:endif :elseif y!<0:if x!<y!:w!=pi!+arctan(-y!/-x!):else :w!=pi!*1.5-arctan(-x!/-y!)
endif :return w!:else :w!=pi!:return w!:endif :endif :Print " ArcTan4 ERROR":waitinput 1e5
endproc
MAIN:
var s!=100 ' Size
var f!=pi()/180
Declare x!,y!,r!,phi!,w!,n&,\
\
Symmetrie!,Form1!,Form2!,Form3!,xHalbachse!,yHalbachse! :var Data$=\
"3 5 18 18 1 1 "+"6 20 7 18 1 1 "+"4 2 4 13 1 1 "+"7 2 4 17 1 1 " +\
"7 3 6 6 1 1 "+"3 3 14 2 1 1 "+"19 9 14 11 1 1 "+"12 15 20 3 1 1 "+\
"8 1 1 8 1 1 "+"8 1 5 8 1 1 "+"8 3 4 3 1 1 "+"8 7 8 2 1 1 "+\
"5 2 6 6 1 1 "+"6 1 1 6 1 1 "+"6 1 7 8 1 1 "+"7 2 8 4 1 1 "+\
"3 2 8 3 1 1 "+"3 6 6 6 1 1 "+"4 1 7 8 1 1 "+"4 4 7 7 1 1 "+\
"2 2 2 2 1 1 "+"2 1 1 1 1 1 "+"2 1 4 8 1 1 "+"3 2 5 7 1 1"
Declare LSymmetrie!,LForm1!,LForm2!,LForm3!,LxHalbachse!,LyHalbachse!
Declare p!,q!, p1!,p2!,p3!,p4!,p5!,p6!
Nochmal:
Whileloop 0,23:n&=&Loop
Symmetrie!=val(substr$(Data$,6*n&+1," "))
Form1!=val(substr$(Data$,6*n&+2," "))
Form2!=val(substr$(Data$,6*n&+3," "))
Form3!=val(substr$(Data$,6*n&+4," "))
xHalbachse!=val(substr$(Data$,6*n&+5," "))
yHalbachse!=val(substr$(Data$,6*n&+6," "))
Whileloop 200,0,-2
p!=&Loop/200:q!=1-p!
p1!=LSymmetrie!*p!+Symmetrie!*q!
p2!=LForm1!*p!+Form1!*q!
p3!=LForm2!*p!+Form2!*q!
p4!=LForm3!*p!+Form3!*q!
p5!=LxHalbachse!*p!+xHalbachse!*q!
p6!=LyHalbachse!*p!+yHalbachse!*q!
phi!=0
r!=Superformel(phi!,p1!,p2!,p3!,p4!,p5!,p6!)
To_xy(r!,phi!)
'cls 0:locate 1,1:print " ";n&;" - ";&Loop;" "
MCLS %maxx, %maxy, 0'$FFFFFF
StartPaint -1
Usepen 0,12,rgb(0,255,0)
moveto xh&+s!*x!,yh&-s!*y!
whileloop 0,360,3 :phi!=f!*&Loop
r!=Superformel(phi!,p1!,p2!,p3!,p4!,p5!,p6!)
To_xy(r!,phi!):Lineto xh&+s!*x!,yh&-s!*y!
endwhile
EndPaint
MCopyBMP 0, 0 - %maxx,%maxy > 0, 0; 0
' waitinput 42
Endwhile
LSymmetrie!=Symmetrie!
LForm1!=Form1!
LForm2!=Form2!
LForm3!=Form3!
LxHalbachse!=xHalbachse!
LyHalbachse!=yHalbachse!
waitinput 1000
'cls 0
Endwhile
beep
n&=0
goto "Nochmal"
Alles anzeigen
Abt. Zeitbedarf für Message-abholendes Waitinput stark reduzieren
================================================
Jens-Arne Reumschüssel fand dazu kürzlich eine Lösung, die ohne API-Fummelei auskommt und eine deutliche Beschleunigung sowohl im Interpreter als auch Compiler bringt. Dazu im Anhang ein kleiner Benchmark.
Gruss
WindowTitle "Messageabholendes Waitinput beschleunigt:"+\
" Lösung von Jens-Arne Reumschüssel testen"
'(CL) CopyLEFT 2019-01 by P.Specht, Vienna/AT/EU
CLS:Randomize:font 2
declare n&,tm&,i&,x&,y&,txt$,ungueltig&
$IFNDEF COMPILER
txt$="INTERPRETER"
n&=2500
$ELSE
txt$="COMPILER"
n&=4000
$ENDIF
AppendMenuBar 100," "+txt$+" zählt bis "+str$(n&)+\
". ESC-Taste soll erkannt werden und zerstört den laufenden Test!"
print "\n OHNE Beschleunigung:",:x&=%pos:y&=%csrlin
waitinput 3:sound 200,20:ungueltig&=0
tm&=&GetTickCount
Whileloop n&:locate 20,20:print &Loop;" ";
i&=&Loop
waitinput 3
:if %Key="27":ungueltig&=1:break:endif
Endwhile
tm&=&GetTickCount-tm&
locate y&,x&
ifnot ungueltig&: print tm&,"ms"
else :print "<abgebrochen>":clear ungueltig&
Endif
print "\n NUR Fastmode:",:x&=%pos:y&=%csrlin
waitinput 3:sound 200,20:ungueltig&=0
tm&=&GetTickCount
set("Fastmode",1)
Whileloop n&:locate 20,20:print &Loop;" ";
waitinput 3
:if %Key="27":ungueltig&=1:break:endif
Endwhile
set("Fastmode",0)
tm&=&GetTickCount-tm&
locate y&,x&
ifnot ungueltig&: print tm&,"ms"
else :print "<abgebrochen>":clear ungueltig&
Endif
print "\n NUR MIT rnd()-Chance:",:x&=%pos:y&=%csrlin
waitinput 3::sound 200,20:ungueltig&=0
tm&=&GetTickCount
Whileloop n&:locate 20,20:print &Loop;" ";
if rnd()>0.95
waitinput 3
:if %Key="27":ungueltig&=1:break:endif
endif
Endwhile
tm&=&GetTickCount-tm&
locate y&,x&
ifnot ungueltig&: print tm&,"ms"
else :print "<abgebrochen>":clear ungueltig&
Endif
print "\n LÖSUNG von Jens-Arne R.: Fastmode mit %PeekMessage:",:x&=%pos:y&=%csrlin
waitinput 3:sound 200,20:ungueltig&=0
tm&=&GetTickCount
set("Fastmode",1)
Whileloop n&:locate 20,20:print &Loop;" ";
if %PeekMessage
waitinput 3
:if %Key="27":ungueltig&=1:break:endif
Endif
Endwhile
set("Fastmode",0)
tm&=&GetTickCount-tm&
locate y&,x&
ifnot ungueltig&: print tm&,"ms"
else :print "<abgebrochen>":clear ungueltig&
Endif
print "\n OHNE JEDE ABFRAGE:",:x&=%pos:y&=%csrlin
waitinput 3:sound 200,20:ungueltig&=0
tm&=&GetTickCount
Whileloop n&:locate 20,20:print &Loop;" ";
:
Endwhile
tm&=&GetTickCount-tm&
locate y&,x&
ifnot ungueltig&: print tm&,"ms"
else :print "<abgebrochen>":clear ungueltig&
Endif
hold:
sound 2000,60
Waitinput 7000:casenot %wmTimer:goto "hold"
END
Alles anzeigen
Abt. Wie schnell bewegen sich Programmierer?
==================================
Die tägliche Erddrehung verleiht einem Punkt am Äquator eine Geschwindigkeit von etwa 464 m/s = 1670 km/h,
einem sitzenden Münchner auf 48.1351° Nördl. Breite immer noch 1115 km/h.
Bezogen auf die jährliche Umkreisung der Sonne hat die Erde eine Geschwindigkeit von fast 30 Kilometern pro Sekunde,
das sind rund 107.600 km/h. Das Sonnenesysstem selbst ist etwa 25.000 Lichtjahre vom Zentrum der Milchstraße entfernt und braucht für einen Umlauf grob 240 Millionen Jahre. Daraus folgt, daß sich das Sonnensystem mit rund 220 Kilometern pro Sekunde, das sind 782.000 km/h, in der Galaxie um das Zentrum bewegt.
Die aus Messungen gegenüber der Hintergrundstrahlung des Universums abgeleitete Summe der verschiedenen Geschwindigkeitskomponenten unseres Sonnensystems beträgt etwa 370 Kilometer pro Sekunde bzw. 1.332.000 km/h.
Die Milchstraße und ihre benachbarten Galaxien bilden nämlich die so genannte Lokale Gruppe, die sich auf das Sternbild Jungfrau (den Virgo-Haufen) zubewegt. Die Geschwindigkeit dieses Galaxienhaufens wurde zu etwa 630 Kilometer pro Sekunde = 2.268.000 km/h errechnet.
Frage: Sind das nicht bereits relativistische Geschwindigkeiten?
Kontrollrechnung :
Lichgeschwindigkeit 299792,458 km/s = 17.987.547,48 km/min = 1.079.252.849 km/h
2.268.000 km/h / 1.079.252.848,8 km/h = 0.002101454
Antwort: Programmierer bewegen sich mit 0.21 % der Lichtgeschwindigkeit.
Fortsetzung: ... und das gilt auch für die ggw. 28.504 angemeldeten Mitglieder von Paules PC-Forum, + 1 Info-Bot, minus einige Doubletten, Karteileichen und tatsächlich Verstorbene. Mit anderen Worten: Hier bewegen sich rund 28.400 Mitglieder mit 0.21 % der Lichtgeschwindigkeit weiter!
Abt. Paralellogramm-Gleichung
====================
Die Paralellogramm-Gleichung macht eine Aussage über die Quadrate der beiden Parallelogrammseiten im Verhältnis zu den Quadraten über der beiden Diagonalen dieses Parallelogramms (In der Schule war mir das offenbar vollkommen entgangen, deshalb hat es mich heute so erstaunt!).
In Vektorform lautet diese Gleichung: ||a+b||^2 + ||a-b||^2 = 2*(||a||^2 + ||b||^2),
wobei ||..|| ´Länge von x´ bzw. Abstand bedeutet (Mathematiker nennen das ´Norm´).
In Komponentenschreibweise - für Computer ohne Vektor-Mathematikpaket - kann man das so schreiben:
(ax+bx)^2+(ay+by)^2 + (ax-bx)^2+(ay-by)^2 = 2 * (ax^2+ay^2 + bx^2+by^2)
bzw. in XProfan:
sqr(ax+bx)+sqr(ay+by) + sqr(ax-bx)+sqr(ay-by) = 2 * (sqr(ax)+sqr(ay) + sqr(bx)+sqr(by))
Probieren wir doch mal mit verschiedenen Werten, ob das stimmt:
WindowTitle "Parallelogrammgleichung überprüfen"
CLS:font 2:randomize
AppendMenuBar 100," Zufallswert 1 "+\
"Zufallswert 2 Abs. u. Relativer Fehler"
Declare ax!,ay!,bx!,by! 'Zufallwerte in weitem Bereich
Declare z1!,z2! 'Linke und rechte Gleichungsseite
Declare z3! 'Relativer Fehler, Alarm falls > 10^-15
Nochmal:
ax!=(1-2*rnd(2))*rnd()*10^(rnd(200)-100)
ay!=(1-2*rnd(2))*rnd()*10^(rnd(200)-100)
bx!=(1-2*rnd(2))*rnd()*10^(rnd(200)-100)
by!=(1-2*rnd(2))*rnd()*10^(rnd(200)-100)
z1!= sqr(ax!+bx!)+sqr(ay!+by!) + sqr(ax!-bx!)+sqr(ay!-by!)
z2!= 2*(sqr(ax!)+sqr(ay!) + sqr(bx!)+sqr(by!))
print tab(2);format$("%g",z1!);tab(26);format$("%g",z2!),
print tab(50);format$("%g",z1!-z2!)
if (z1!-z2!)<>0
z3!=abs((z1!-z2!)/z1!)
print tab(39);"Rel.Error: ";format$("%g",z3!)
waitinput 1200
if z3!>val("1e-15")
sound 2000,200
Print "\n F E H L E R A L A R M bei folgenden Komponenten:"
print ax!
print ay!
print bx!
print by!
waitinput
waitinput
endif
endif
'waitinput 10'000
goto "Nochmal"
Alles anzeigen
Bei mir sieht es so aus als ob es stimmt - Beweis ist das im strengen Sinne natürlich keiner.
Gruss
P.S.: Wer die einleuchtende geometrische Deutung dieser Sache wissen will, kann sich in diesem informativen Youtube-Video von Prof. Weitz schlau machen.
PPS.: Den echten Beweis gibt´s nachstehend im Spoiler!
Die Parallelogrammgleichung:
(ax+bx)^2+(ay+by)^2 + (ax-bx)^2+(ay-by)^2 = 2 * (ax^2+ay^2 + bx^2+by^2)
ergibt mit ausgerechneten Quadraten:
(ax^2+bx^2+2*ax*bx) +(ay^2+by^2+2*ay*by) + (ax^2+bx^2-2*ax*bx)+(ay^2+by^2-2*ay*by) =
= 2 * (ax^2+ay^2 + bx^2+by^2)
bzw. ohne die unnötigen Klammern:
ax^2+bx^2+2*ax*bx + ay^2+by^2+2*ay*by + ax^2+bx^2-2*ax*bx + ay^2+by^2-2*ay*by =
= 2 * ax^2+2 * ay^2 + 2 * bx^2+2 * by^2
und etwas georndeter:
ax^2+ ax^2 + ay^2+ ay^2 + bx^2+bx^2 + by^2+by^2 + 2*ax*bx +2*ay*by -2*ax*bx -2*ay*by =
= 2 * ax^2+2 * ay^2 + 2 * bx^2+2 * by^2 ,
somit:
2*ax^2+2*ay^2+2*bx^2+2*by^2 + 2*ax*bx +2*ay*by -2*ax*bx -2*ay*by =
2*ax^2+2*ay^2+2*bx^2+2*by^2 ,
was soviel bedeutet wie
2*ax*bx-2*ax*bx + 2*ay*by -2*ay*by = 0,
daher 0 = 0, und das stimmt ja wohl auch!
q.e.d.
------
Korrektur zu oben: Richtig ist ParaLLeLogramm, nicht Paralello... Man soll eben keine Beiträge in später Nacht schreiben, denn da droht Umnachtung
Abt. Speicherverwaltung dreidimensionaler Matrizen
=====================================
XProfan (V. 11.2a) funktioniert mit der "Am-Stück"-Speicherverwaltung nur für statisch deklarierte Listen und für Matrizen mit von vorneherein definierter Größe. Dann aber lässt sich sicher zugreifen, wenn man die Indexverwaltung (und den Speicherbedarf für ein Einzelelement) richtig einsetzt. Dazu die nachstehende kleine Studie.
Gruss
WindowTitle "Studie: Speicher- und Zugriffsorganisation"+\
"auf dreidimensionale Matrizen (a.k.a. Tensoren)"
Cls:randomize
'Speicherbedarf eines Einzelwertes (XProfan):
var SB&=8 'Double precision Floatingpoint: 8 Byte
'Stellenzahlen
var xm&=2
var ym&=2
var zm&=2
declare x&,y&,z&, M![xm&-1,ym&-1,zm&-1]
M![]=&index 'rnd()
print
print "Händisch für M[x,y,z]:"
print M![0,0,0],M![0,0,1]," ",M![0,1,0],M![0,1,1]
print M![1,0,0],M![1,0,1]," ",M![1,1,0],M![1,1,1]
print
print "Vereinfacher x-Komponentenaufruf:"
print M![0]
print M![1]
print
print "Linear programmierter Aufruf:"
Whileloop 0,zm&-1:z&=&Loop
Whileloop 0,ym&-1:y&=&Loop
whileloop 0,xm&-1:x&=&Loop
print float( addr(M![0]),SB&*(x& * ym&*zm& + y& *zm& + z&)),
EndWhile:print " ";
Endwhile:print
Endwhile:print
waitinput
Alles anzeigen
Abt. Ältere Profan-Sourcecodes
====================
benötigen die Include-Datei ProfAlt.Inc und können dann klaglos auch mit neueren XProfan-Versionen ausgeführt werden. Voraussetzung ist eine vorangestellte gültige Einbindung mittels $I ProfAlt.inc , wobei es sich u.U. empfiehlt die Datei in das Arbeitsverzeichnis mitzukopieren, um sie in Projekt-Zips stets mit dabei zu haben.
Für eigene Zwecke habe ich mal die Häufigkeit der alten Befehle in meiner Sammlung älterer Programmsourcen analysiert, und die ProfAlt.inc so getuned, daß die häufigsten Befehle am raschesten gefunden werden. Je nach Programm ist eine gewissen Beschleunigung festzustellen - oder auch nicht. Schaden tut das Verfahren jedenfalls nicht. Anbei die ´tiefergelegte´ Version, ProfAlt_v2.Inc
Gruss
:PROC ADD :PARAMETERS A!,B!:RETURN A!+B!:ENDPROC
:PROC MUL :PARAMETERS A!,B!:RETURN A!*B!:ENDPROC
:PROC SUB :PARAMETERS A!,B!:RETURN A!-B!:ENDPROC
:PROC EQU :PARAMETERS A!,B!:RETURN A!=B!:ENDPROC
:PROC NEQ :PARAMETERS A!,B!:RETURN A!<>B!:ENDPROC
:PROC LT :PARAMETERS A!,B!:RETURN A!<B!:ENDPROC
:PROC GT :PARAMETERS A!,B!:RETURN A!>B!:ENDPROC
:PROC DIV :PARAMETERS A!,B!:RETURN A!/B!:ENDPROC
:PROC POW :PARAMETERS A!,B!:RETURN A!^B!:ENDPROC
:PROC MOD :PARAMETERS A!,B!:RETURN A! MOD B!:ENDPROC
:PROC DIV& :PARAMETERS A!,B!:RETURN A!\B!:ENDPROC
:PROC ADD$ :PARAMETERS A$,B$:RETURN A$+B$:ENDPROC
:PROC EQU$ :PARAMETERS A$,B$:RETURN A$=B$:ENDPROC
:PROC NEQ$ :PARAMETERS A$,B$:RETURN A$<>B$:ENDPROC
:PROC LT$ :PARAMETERS A$,B$:RETURN A$<B$:ENDPROC
:PROC GT$ :PARAMETERS A$,B$:RETURN A$>B$:ENDPROC
'= Include-Datei für Quellcodes früher Profan-Versionen, die
' noch keine Operatoren nutzen. Einbinden mit $I ProfAlt_v2.inc
Alles anzeigen
Abt. Torte teilen für Fortgeschrittene
=======================
Bei einem Mathe-Quiz, das eine Nummer zu groß für mich war, tauchte die Frage auf, in wieviele Teilstücke ein Kreis maximal zerfällt, wenn man N Randpunkte beliebig irgendwo am Kreisumfang platziert und von jedem Randpunkt zu jedem anderen Randpunkt gerade Schnitte macht. Anm.: Im Gegensatz zu einem bekannten Rätsel, bei dem die Anzahl der Schnitte vorgegeben ist - und das wir in dieser Reihe schon behandelt haben - geht es hier um vorgegebene Eckpunkte, also ggf. auch um eine ungerade Anzahl von Eckpunkten!
Klar ist, daß der Kreis dann N*(N-1)/2 Schnitte enthält, die alle so geführt werden müssen, daß dabei immer nur jeweils 2 Schnitte einander in einem Kreuzungspunkt treffen dürfen - die Kreuzungen also alle nicht mehr als 4 Äste haben. In meiner naiven Art habe ich also Kreise und Eckpunkte zu zeichnen begonnen und die Flächen abgezählt. Das Verfahren empfiehlt sich allerdings nur für geringe Ecken-Anzahlen. Schon ab 7 oder 8 Ecken ergibt sich, daß Punkte versetzt werden müssen, weil sich rasch mehr als 2 Schnitte in einem Kreuzungspunkt treffen - d.h.: Alles nochmals zeichnen...
Während ich also bastelte, gab der Sieger folgende Formel an: Der Kreis zerfällt bei geeigneter Wahl von N Punkten am Kreisumfang in 1/24*(N^4 - 6*N^3 + 23*N^2 - 18*N + 24) Flächenstücke.
Was soll ich sagen: Scheint zu stimmen!
Gruss
P.S.: Meine amateurhaften Versuche führten zu dem nachfolgenden, letztlich vollkommen sinnlosen Programm. Sollt auch was davon haben, geteiltes Leid ist ja halbes Leid ...
WindowTitle "MISSGLÜCKTES Stern-Netz möglichst mit 4-Ast-Kreuzungen"
randomize:var N&= 4+rnd(14)
WindowStyle 24:Window 0,0 - %maxx,%maxy
declare xh&,yh&:xh&=width(%hwnd)\2:yh&=height(%hwnd)\2
declare x!,y!,w!,r!,f!,d&,i&,j&
declare px![n&-1],py![n&-1]
f!=pi()/180:d&=3
r!=300
usepen 0,3,rgb(255,0,0)
whileloop 0,n&-1
w!=&Loop*f!*360/n&
px![&Loop]=(1+(n&>5)*rnd()/Sqrt(n&))*r!*cos(w!)
py![&Loop]=(1+(n&>5)*rnd()/Sqrt(n&))*r!*sin(w!)
ellipse xh&+px![&Loop]-d&,(yh&-py![&Loop]-d&)\
- xh&+px![&Loop]+d&, yh&-py![&Loop]+d&
endwhile
locate 4,40:print "N = ";n&
usepen 0,1,rgb(0,0,0)
whileloop 0,n&-1:i&=&Loop
whileloop i&+1,n&-1:j&=&Loop
case abs(i&-j&)=1:continue
case (i&=0) and (j&=N&-1):continue
Line xh&+px![i&],(yh&-py![i&]) - xh&+px![j&],yh&-py![j&]
endwhile
endwhile
waitinput
waitinput 'Shift+Druck für Screencopy
Alles anzeigen
Abt. X-Y-ungelöst: Weitere Quizfrage (Fortsetzung von oben)
=======================
Noch nicht frustriert genug, habe ich auch bei der nächsten Quizfrage versucht, mitzukommen: Die Frage lauutete nun, wieviele KREUZUNGSPUNKTE im Szenario des vorigen Beitrags auftreten. Also habe ich zuerst wieder mit Aufzeichnen (bzw. ausdrucken) und zählen begonnen. Dabei wurde klar, daß die Randverbindungen und Direktverbindungen zwischen benachbarten Randpunkten keine Kreuzungen enthalten können. Wir betrachten also hier nur die N * (N-3)/2 inneren verbindenden Schnitte.
Weitere Überlegungen zeigten, daß man Doppelzählungen vermeiden und parallel führende Schnitte durch einfache Größer-Kleiner-Vergleiche erkennen kann. Das ganze floss dann in nachstehendes Progrämmchen, das statt mir das Durchzählen übernimmt. So ab 80 Eckpunkten wird die Sache allerdings sehr zeitaufwaendig.
Ich bin überzeugt, daß es auch dafür eine Formel gibt - nur bin ich zu doof um sie zu finden, und warte daher wieder auf einen SiegerInnen-Typ unter der geneigten Leserschaft.
Gruss
WindowTitle "Vier-Ast-Kreuzungen eines vollständigen N-Sterngraphen"
'(CL) CopyLeft 2019-01 by P.Specht, Vienna/EU
Windowstyle 24:CLS:randomize
declare N&,i&,j&,u&,v&,x&,y&,tm&,z&
declare Mi&[],Mj&[],Mu&[],Mv&[],count&
LUP:
clear N&,i&,j&,u&,v&,Mi&[],Mj&[],Mu&[],Mv&[],count&
font 0
Print "\n\n Gewünschte Zahl der Eckpunkte des Sterngraphen = ";
input N&
tm&=&gettickcount 'Start des Aufsetzens:
whileloop 0,N&-3:i&=&Loop
whileloop i&+2,N&-1-(i&=0):j&=&Loop
' print " ";i&,j&," ",
Mi&[sizeof(Mi&[])]=i&
Mj&[sizeof(Mj&[])]=j&
if i&>0
Mu&[sizeof(Mu&[])]=i&
Mv&[sizeof(Mv&[])]=j&
' print i&,j&,
endif
' print
endwhile
Endwhile
print "\n Prüfung der",int(n&*(n&-1)/2),"Direktverbindungen läuft: ";
whileloop 0,sizeof(Mi&[])-2:x&=&Loop:case rnd()<(n&/200):print "~";
whileloop 0,sizeof(Mu&[])-1:y&=&Loop
if Mi&[x&]<Mu&[y&]
if Mu&[y&]<Mj&[x&]
if Mj&[x&]<Mv&[y&]
inc count&
endif
endif
endif
endwhile
endwhile
tm&=&gettickcount-tm&
font 2
print "\n Ein vollständiger Sterngraph mit",N&,"Ecken hat",
print count&,"Kreuzungen."
Sound 50,100:font 0:print "\n Rechendauer",
if tm&<1000:print tm&,"ms.":elseif tm&<60000:print tm&/1000,"s"
else:print tm&/60000,"min":endif
if %csrlin>31:waitinput:cls:endif
goto "LUP"
Alles anzeigen
P.S. Ein Beispiel zu oben:
-----------------------------
Ein vollständiger Sterngraph mit N = 100 Ecken hat 4.950 Direktverbindungen bzw. 4850 Innenverbindungen, die K = 3.921.225 vierÄstige Kreuzungen aufweisen. Das obige Programm brauchte zu dieser Durchzählung 14.66 min.
Abt. Frustrationsformeln
==================
1) Die in Beitrag #73 angegebene Formel für Flächenstücke, die bei Kreisteilung zwischen N Randpunkten entstehen, verschafft Mathematikern Frustrationserlebnisse - geht die Reihe doch: 1, 2, 4, 8, 16, ... Jedem Normalo fällt sofort eine Fortsetzung ein: 32. Die Formel liefert aber korrekterweise 31. Ätsch!
2) Der Größe gemeinsamte Teiler GgT von n^17+9 und (n+1)^17+9) ist stets 1 für alle n. So dachte man lange, bis ein findiger Zeitgenosse die Zahl n = 8424432925592889329288197322308900672459420460792433 fand. Ab da kommen dann alle möglichen GgT-Ergebnisse vor. Ätsch!
3) Die Formel f(n)=n^2+n+41, so dachten viele Mathematiker vor Leonhard Euler, erzeugt lauter Primzahlen.
Euler bewies dann: Nö, doch nicht, nur bis 39:
Zwar gilt für f(1)=43 prim!, f(2)=47 prim!, ..., f(30)=971 alle prim! aaaaaaaber:
n=40 liefert f(40)=1681 = 41*41 daher nicht prim, f(41)=1763 = 41*43 <> prim! ... Ätsch!
4) Zahlreiche mathematische Vermutungen lassen sich mit Computerhilfe für jede einzelne Zahl bis in den Milliardenbereich nachrechnen - bisher fand man nicht eine einzige Abweichung. Dennoch gilt so etwas nicht als mathematischer Beweis - aus Gründen, die Beispiel 2 besonders deutlich zeigt. Erstaunlich, daß es doch immer wieder neue, hieb- und stichfeste mathematische Schlußfolgerungen und Axiome gibt - mit viel Grips halt. Im Kopf addieren können reicht da nicht aus...
Gruss
Abt. EaR 15 ´Die Superzahl´
=====================
Gesucht ist eine ganze Zahl, die aus den Ziffern 1 bis 9 besteht und ...
deren 1. Stelle durch 1 ohne Rest teilbar ist (trivial),
deren durch die ersten beiden Stellen (von links gerechnet) gebildete Zahl durch 2 ohne Rest teilbar ist,
deren durch die ersten 3 Stellen (von links gerechnet) gebildete Zahl durch 3 ohne Rest teilbar ist,
... usw., bis:
deren durch alle 9 Stellen gebildete Zahl durch 9 ohne Rest teilbar ist.
Programmierte Lösungen sind zulässig, es geht aber auch anders.
Viel Spaß!
Lösung zu EAR 15
-----------------
Entweder mit Computer-Power:
Windowtitle "Superzahl 1-9 bzw. 1-9 & 0 ermittlen"
WindowStyle 24:CLS:font 2
declare x0&,x1&,x2&,x3&,x4&,x5&,x6&,x7&,x8&,x9&,z!
Whileloop 1,9:x0&=&Loop
Whileloop 0,9:x1&=&Loop
case x1&=x0&:continue
z!=10*x0&+x1&
casenot z!=2*int(z!/2):continue
Whileloop 1,9:x2&=&Loop
case x2&=x1&:continue
case x2&=x0&:continue
z!=100*x0&+10*x1&+x2&
casenot z!=3*int(z!/3):continue
Whileloop 0,9:x3&=&Loop
case x3&=x2&:continue
case x3&=x1&:continue
case x3&=x0&:continue
z!=1000*x0&+100*x1&+10*x2&+x3&
casenot z!=4*int(z!/4):continue
Whileloop 1,9:x4&=&Loop
case x4&=x3&:continue
case x4&=x2&:continue
case x4&=x1&:continue
case x4&=x0&:continue
casenot (x4&=0) or (x4&=5):continue
Whileloop 0,9:x5&=&Loop
case x5&=x4&:continue
case x5&=x3&:continue
case x5&=x2&:continue
case x5&=x1&:continue
case x5&=x0&:continue
z!=100000*x0&+10000*x1&+1000*x2&+100*x3&+10*x4&+x5&
casenot z!=6*int(z!/6):continue
Whileloop 0,9:x6&=&Loop
case x6&=x5&:continue
case x6&=x4&:continue
case x6&=x3&:continue
case x6&=x2&:continue
case x6&=x1&:continue
case x6&=x0&:continue
z!=1000000*x0&+100000*x1&+10000*x2&+\
1000*x3&+100*x4&+10*x5&+x6&
casenot z!=7*int(z!/7):continue
Whileloop 0,9:x7&=&Loop
case x7&=x6&:continue
case x7&=x5&:continue
case x7&=x4&:continue
case x7&=x3&:continue
case x7&=x2&:continue
case x7&=x1&:continue
case x7&=x0&:continue
z!=10000000*x0&+1000000*x1&+100000*x2&+\
10000*x3&+1000*x4&+100*x5&+10*x6&+x7&
casenot z!=8*int(z!/8):continue
Whileloop 1,9:x8&=&Loop
case x8&=x7&:continue
case x8&=x6&:continue
case x8&=x5&:continue
case x8&=x4&:continue
case x8&=x3&:continue
case x8&=x2&:continue
case x8&=x1&:continue
case x8&=x0&:continue
z!=100000000*x0&+10000000*x1&+1000000*x2&+\
100000*x3&+10000*x4&+1000*x5&+100*x6&+10*x7&+x8&
'print z!,9*int(z!/9)
casenot z!=9*int(z!/9):continue
x9&=45-x0&-x1&-x2&-x3&-x4&-x5&-x6&-x7&-x8&
casenot x9&=0:continue
print "\n\n\n ";\
x0&,x1&,x2&,x3&,x4&,x5&,x6&,x7&,x8&,"(";x9&;")"
Endwhile
Endwhile
Endwhile
Endwhile
Endwhile
Endwhile
Endwhile
Endwhile
Endwhile
print "\n\n\n OK"
beep:waitinput
End
Alles anzeigen
oder mit Grips : Youtube-Link (dt.)
Abt. Float-Gefahren
===============
XProfans 64-bit lange "Double precision floating point"-Variablen, etwa x!, bergen bekanntlich Gefahren in sich, die man als Anwender kennen sollte. Folgende Operationen liefern nur Ergebnisse begrenzter Genauigkeit, und verlässt man dabei übliche Zahlenbereiche, kommt es nicht nur zu Rundungsfehlern wie sie jedermann/jederfrau auch beim normalen Dividieren und Subtrahieren passieren können, sondern es kommt noch die Tatsache hinzu, daß es Zahlen gibt, die im Dezimalsystem zwar exakt darstellenbar sind, binär aber nur näherungsweise.
1 - 0.9 ist exakt 0.1, der Computer macht daraus 0.099999999999999998
... und schon gehen Vergleichsabfragen wie größer oder größer gleich schief.
1 - dieser obige Wert sollte also 0.9 liefern: 1 - 0.099999999999999998 lierfert aber 0.9000000000000002
1/3 liefert nicht 0.33333333333333333, sondern 0.33333333333333331
2/3 liefert nicht 0.66666666666666667, sondern 0.66666666666666663
1 - 1/3 sollte auch 2/3 ergeben, liefert aber 0.66666666666666674
usw. usw.
Krass wird die Sache, wenn man in die Randbereiche binärer Darstellungsmöglichkeiten gerät. Hier beginnt der Rechner die Zahlen immer gröber und gröber zu behandeln und phanatsiert schon mal Einer-, Zehner- und Hunderterstellen hinzu. Fachleute nennen das den "De-Normalisierungsbereich". Da leidet allerdings nur die Genauigkeit. Die absoluten Katastrophen aber treten ein, wenn man folgende Werte über- bzw. unterschreitet:
Werte größer als
+\- 8.98846567431158E307 = 2^1024, rückkonvertiert +/- 898846567431157954E+298
Folge: Fataler Fehler mit Programmabbruch
Werte kleiner als
+\- 4.9406564584127E-324 = 2^-1074, rückkonvertiert +\- 494065645841246544E-341
Unerklärliche Not-a-number-Nullwerte (NAN), die bei Folgeoperationen zu völlig unerklärlichem Verhalten führen können, bzw. bei Divisionen zu nicht abfangbaren Abstürzen.
Gruss
Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!