Home

Schulzeitnostalgie,Taschenrechner und transzendente Zahlen

Montag, 16. April 2012 | Autor:

Damals™ in der Schu­le hat­ten wir Taschen­rech­ner. Zu Anfang eher ein ein­fa­ches Modell: Grund­re­chen­ar­ten, ele­men­ta­re Funk­tio­nen – passt. Spä­ter dann wech­sel­ten wir zu einem deut­lich aus­ge­feil­te­ren Modell – dem TI-83! Der kann auch Funk­tio­nen zeich­nen, nume­risch inte­grie­ren und ablei­ten, man kann mit Matri­zen rech­nen, Sta­tis­tik betrei­ben und vie­les ande­res mehr! Was mir auch sehr gut gefiel: Es gab ein dickes Hand­buch dazu, in dem alle sei­ne Funk­tio­nen und Ein­stel­lun­gen beschrie­ben waren. Eine rich­ti­ge gute Anlei­tung, die zum Mit­ma­chen ein­lud – ein­fach toll!

Aber das Aller­bes­te war: mei Mama hat Ame­ri­ka­ner bache­le  Der Taschen­rech­ner war pro­gram­mier­bar! Bezie­hungs­wei­se ist – ich habe ihn immer noch. Im Nach­hin­ein betrach­tet, war der TI-83 wohl das, was für frü­he­re Genera­tio­nen der C64 war: mei­ne Ein­stiegs­dro­ge zur Infor­ma­tik. Ich habe wirk­lich viel pro­gram­miert: In den Pau­sen, im Bus, wäh­rend des Mit­tag­essens. Ich habe ihn auch in den Urlaub mit­ge­nom­men! Dazu muss man wis­sen: wir hat­ten ein Wohn­mo­bil, da war der Taschen­rech­ner, der dank der Pro­gram­me ande­rer auch gleich­zei­tig Spie­le­kon­so­le war, ein guter Lan­ge­wei­le­kil­ler auf lan­gen Fahr­ten (Fahr­ten in Schwe­den sind immer lang). Außer­dem war das noch nicht die Zeit alles­kön­nen­der Immer-dabei-Elek­tro­nik, also konn­te man den Taschen­rech­ner auch aus prak­ti­schen Grün­den recht­fer­ti­gen. Pro­gram­me aus die­ser Zeit pro­to­kol­lier­ten zum Bei­spiel den Ben­zin­ver­brauch oder rech­ne­ten Wäh­run­gen um.

Aber zurück zum The­ma: Das prak­ti­sche an Pro­gram­men ist ja, dass sie mono­to­ne Auf­ga­ben für einen über­neh­men, sodass man sich selbst ganz auf den inter­es­san­ten krea­ti­ven Part stür­zen kann! Mathe­auf­ga­ben zum Bei­spiel: Ich habe jedes Pro­blem, das wir in Mathe behan­delt haben, zeit­nah in ein Pro­gramm umge­setzt. Das ist ein­fa­cher, als es klingt, denn die meis­ten die­ser Schul-Mathe­ma­tik-Din­ger bestehen ja nur aus einer ein­zel­nen Glei­chung, mei­net­we­gen die Gera­den­glei­chung oder die For­mel zur Lösung Qua­dra­ti­scher Glei­chun­gen. Typi­sche Pro­gram­me sahen so aus: Der Start­bild­schirm frag­te, wel­che Grö­ßen gege­ben waren. Dann wur­de man gebe­ten, die­se ein­zu­ge­ben. Danach rech­ne­te das Pro­gramm die ein­schlä­gi­ge und pas­send umge­stell­te Glei­chung aus und zeig­te das Ergeb­nis an. Kei­ne gro­ße Sache, aber eine immense Zeit­er­spar­nis! Vor allem in Klau­su­ren habe ich jede Men­ge Zeit gewon­nen, die ich anders­wo bes­ser gebrau­chen konn­te. Mei­ne (übri­gens sehr guten) Leh­rer haben zwar auf den Lösungs­weg gepocht, aber ich habe mei­ne Pro­gram­me dann ein­fach umge­schrie­ben, sodass sie auch die Zwi­schen­schrit­te anzeig­ten.

Nun gibt es aber bei Taschen­rech­nern ein Pro­blem: Sie spu­cken so Zah­len aus wie
1.41421356
Zah­len mit begrenz­ter Genau­ig­keit ohne tie­fe­ren Sinn. Wenn man die Zah­len aber immer und immer wie­der sieht, erkennt man sie irgend­wann recht schnell. Die Zif­fern­fol­ge 1.414… ist zum Bei­spiel meist kein Zufall, son­dern ein­fach die Wur­zel aus Zwei. War­um man das wis­sen möch­te? Allein schon, um nicht immer „1.41421356“ schrei­ben zu müs­sen ;). Ein ande­rer Zweck ist fol­gen­der: Wenn man in einem Test als Ergeb­nis „1.41421356“ hin­schreibt, weiß der oder die Leh­re­rin sofort, dass man nicht selbst per Hand gerech­net hat, denn per Hand hät­te man in der For­mel direkt gese­hen, dass es Wur­zel 2 ist und es auch so als Ergeb­nis ange­ge­ben!

Wenn man den Ver­dacht hat, dass eine Zahl eine Wur­zel aus irgend­was ist, kann man sie aber ein­fach im Taschen­rech­ner qua­drie­ren:

1.41421356^2
= 2
1.7320509^2
= 3.00000032

Voi­là – schon weiß man Bescheid! Manch­mal kommt es nicht ganz hin. Ent­we­der hat dann die Zahl, die man qua­driert, Rechen­un­ge­nau­ig­kei­ten drin oder die Zahl ist ein­fach wirk­lich nicht die Wur­zel aus 3.

Irgend­wann, wie hät­te es auch anders kom­men sol­len, habe ich mir natür­lich ein Pro­gramm geschrie­ben, dass gleich meh­re­re sol­cher Tricks durch­pro­biert! Ist die Zahl ein Viel­fa­ches von Pi oder e? eine Wur­zel? eine Kubik­wur­zel? das Inver­se von irgend­was? Wobei die Hoff­nung natür­lich immer ist, dass die­ses Irgend­was ein­fa­cher ist. Mit „Wow, 1.7320509 ist genau das 0.637185917fache von e!“ kann man nie­man­den beein­dru­cken.

Lus­ti­ger­wei­se trei­ben sol­che Fra­gen nicht nur fau­le Schü­ler um, son­dern auch Mathe­ma­ti­ker. Kann man jede Zahl als Bruch zwei­er gan­zer Zah­len dar­stel­len? Nö, geht nicht. Die Län­ge der Dia­go­na­len in einem Qua­drat zum Bei­spiel nicht. Sie beträgt √2 und die ist irra­tio­nal.

Irra­tio­na­le Zah­len soll­te jeder mal gehört haben, aber es gibt auch noch soge­nann­te „tran­szen­den­te“ Zah­len. Abge­fah­re­ner Name, aber was ist das? Man soll­te sich in Mathe­ma­tik grund­sätz­lich nicht von Namen ein­schüch­tern las­sen, aber mir passiert’s trotz­dem immer mal wie­der. Gehen wir erst­mal noch n Stück zurück…

Mein Pro­gramm war ursprüng­lich gedacht, um Wur­zeln zu erken­nen. Das hat oft recht gut geklappt oder wenn nicht, dann war die frag­li­che Zahl meist ein Viel­fa­ches von Pi, aber las­sen wir das mal weg und kon­zen­trie­ren wir uns auf die Wur­zeln. Mit­un­ter war eben auch das Qua­drat oder Kubik einer Zahl selbst wie­der­um tota­ler Zah­len­wirr­war.

Bei­spiel. Wir haben aus irgend­ei­ner Berech­nung x=1.618033989 her­aus­be­kom­men und pro­bie­ren unse­ren Stan­dardtrick:

1.618033989^2
= 2.618033989

Ohhhhhkay­y­y­yy. Das Qua­drat der Zahl ist offen­bar die­sel­be (immer­noch wir­re) Zahl plus 1. Das ent­spricht der Glei­chung:

x² – x – 1 = 0

und 1.618033989 ist eine Lösung die­ser Glei­chung. Jetzt könn­te man den­ken: „Hey! Es ist also nicht jede Zahl eine Wur­zel von irgend­was, aber viel­leicht ist ja jede Zahl eine Lösung so einer ein­fa­chen For­mel? So wie x² – x – 1 = 0?“

Die Ant­wort auf die­se Fra­ge wur­de erst 1844 von Liou­vil­le gefun­den und lau­tet:

Nein.

Es gibt Zah­len, für die das nicht geht. Sie wer­den tran­szen­den­te Zah­len genannt. Pi ist zum Bei­spiel eine sol­che Zahl.

Zah­len, die doch Lösung so eines Poly­noms sind, z.B. die oben genann­te 1.618033989…, wer­den alge­bra­isch genannt. Aller­dings sind die­se Zah­len auch nicht unbe­dingt ein­fach, da es für die Lösun­gen von Poly­no­men nicht immer eine geschlos­se­ne Form gibt. Dann lan­det man eben doch wie­der bei lan­gen unin­tui­ti­ven und schwer zu mer­ken­den Zah­len­ko­lon­nen – aber dafür gibt es ja dann Taschen­rech­ner 😉

Thema: Programmieren | Beitrag kommentieren

Dateiendungen bei C++

Mittwoch, 20. Juli 2011 | Autor:

Eine Fra­ge die ich mir damals gestellt habe: Wel­che Datei­endun­gen müs­sen C++-Dateien haben?

Der G++-Compiler akzep­tiert nur eine hand­voll Endun­gen1:

file.cc
file.cp
file.cxx
file.cpp
file.CPP
file.c++
file.C

Aber theo­re­tisch kann man auch .mett­bröt­chen neh­men, wenn man dem Com­pi­ler sagt, dass es C++ sein soll 😀

  1. http://gcc.gnu.org/onlinedocs/gcc/Overall-Options.html

Thema: Programmieren | Beitrag kommentieren

Wahre Worte zum Vertrauen in Karten und Computer

Freitag, 27. Mai 2011 | Autor:

Bei der Recher­che zur Mas­ter­ar­beit gefun­den. Wah­re Wor­te:

Uncer­tain­ty is a cri­ti­cal issue due to the ten­den­cy of most peop­le to tre­at both maps and com­pu­ters as somehow less fal­li­ble than the humans who make decisi­ons they are based upon.

Quel­le: MacEach­ren: Visua­li­zing Uncer­tain Infor­ma­ti­on [PDF]

Thema: Informatik, Programmieren | Beitrag kommentieren

Optimierung

Dienstag, 15. Februar 2011 | Autor:

Ich mache mir oft Gedan­ken, ob mein Code „schnell” ist. Lah­me und inef­fi­zi­en­te Pro­gram­me gibt es schließ­lich schon genug - meins dage­gen soll per­for­mant sein, jawoll!

Es gibt aller­dings ein paar Grund­re­geln beim Opti­mie­ren. Wahr­schein­lich auch mehr als nur ein paar - aber das hier sind die, die ich für mich als prak­tisch und sinn­voll her­aus­ge­fun­den habe. wei­ter…

Thema: Programmieren | Beitrag kommentieren

Ninja-Segfault

Montag, 7. Februar 2011 | Autor:

Letz­te Woche hat­te ich einen Bug, der mich 4 Stun­den und die ent­spre­chen­de Men­ge Ner­ven gekos­tet hat. Der Ori­gi­nal­code ist ziem­lich undurch­sich­tig, des­we­gen habe ich eine klei­ne, kom­pi­lier­ba­re Demo geschrie­ben:

#include <vector>
#include <stack>

class Blubb
{
	public:
		std::vector<int> * liste;
		Blubb() {
			liste = new std::vector<int>(10);
		}
		~Blubb() {
			delete liste;
		}
};

int main()
{
	std::stack<Blubb> stapel;
	Blubb blip;
	stapel.push(blip);
	return 0;
}

Wer meint, C++ zu beherr­schen, darf jetzt grü­beln, war­um die­ser Code einen Seg­fault wirft. Viel Spaß dabei! 😉 wei­ter…

Thema: Sezierte C++-Käfer | 2 Kommentare

Das Semikolon aus einer anderen Welt

Dienstag, 25. Januar 2011 | Autor:

#include "../../math/src/FInterpolation.hh"

/** Interface class for seed lines such as lines, curves, polylines. */
class SeedCurve
{
	public:
		virtual FPosition ipol(double t) = 0;
		virtual vector<FPosition> getPositions(positive number_of_seeds) = 0;
};

gibt eine Feh­ler­mel­dung:

SeedLine.hh:9:1: error: multiple types in one declaration

Meh­re­re Typen in einer Dekla­ra­ti­on.

Der Aus­lö­ser für die­se Mel­dung ist sim­pel, aber viel­leicht nicht offen­sicht­lich: Nach der Dekla­ra­ti­on eines neu­en „Typs”, d.h. einer Klas­se oder eines Struc­ts, wur­de das Semi­ko­lon ver­ges­sen - aller­dings nicht an der Stel­le, die die Feh­ler­mel­dung nennt! 😉 wei­ter…

Thema: Sezierte C++-Käfer | 2 Kommentare

Lange Fehlermeldung, kleine Ursache

Mittwoch, 19. Januar 2011 | Autor:

/home/nico/code/FAnToM/src/visAlgos/StreakSurface/FStreakSurfaceAlgorithm.cc: In member function ‘void FStreakSurfaceAlgorithm::DCELtest()’:
/home/nico/code/FAnToM/src/visAlgos/StreakSurface/FStreakSurfaceAlgorithm.cc:245:43: error: no match for ‘operator<<’ in ‘std::cout << ((DCEL::HalfEdge*)((DCEL::HalfEdge*)((boost::intrusive::detail::add_const_if_c::type*)x.boost::intrusive::list_iterator::operator* [with Container = boost::intrusive::list_impl, (boost::intrusive::link_mode_type)1u, boost::intrusive::default_tag, 1>, long unsigned int, true> >, bool IsConst = false, typename boost::intrusive::detail::add_const_if_c::type& = DCEL::HalfEdge&, typename boost::intrusive::detail::add_const_if_c::type = DCEL::HalfEdge]

wei­ter…

Thema: Sezierte C++-Käfer | 2 Kommentare

Constness of least Surprise

Donnerstag, 6. Januar 2011 | Autor:

Phy­sik­stu­dent Mar­tin K.1 hat mir wie­der einen net­ten klei­nen Bug zuge­tra­gen! Hier erst­mal der Code­aus­schnitt:

QList<qint32> countlist;
	//std::swap funktioniert nicht, daher manuelles tauschen
	int_swap = countlist.at(i);
	countlist.at(i) = countlist.at(j);
	countlist.at(j) = int_swap;
	string_swap = keylist.at(i);
	keylist.at(i) = keylist.at(j);
	keylist.at(j) = string_swap;

Und die Feh­ler­mel­dung:

wortliste.cpp: In function 'void quick_sort(QList<QString>, QList<int>)':
wortliste.cpp:49: error: assignment of read-only location 'countlist.QList<T>::at [with T = int](i)'
wortliste.cpp:50: error: assignment of read-only location 'countlist.QList<T>::at [with T = int](j)'
wortliste.cpp:52: error: passing 'const QString' as 'this' argument of 'QString& QString::operator=(const QString&)' discards qualifiers
wortliste.cpp:53: error: passing 'const QString' as 'this' argument of 'QString& QString::operator=(const QString&)' discards qualifiers

Viel­leicht mal ein paar Wor­te zum Lesen von Feh­ler­mel­dun­gen. wei­ter…

  1. Name nicht im Gerings­ten geän­dert.

Thema: Sezierte C++-Käfer | Beitrag kommentieren

no matching function call

Montag, 27. Dezember 2010 | Autor:

Ein neu­er Tag, eine neue Feh­ler­mel­dung:

/home/nico/code/FAnToM/src/visAlgos/IntegralLines/../../math/src/ODESolver/StreakLine.hh:76:2: error: no matching function for call to ‘Tracer<2, (FLineType)0u>::Tracer(std::vector<MeshNode>, boost::shared_ptr<const FTimeDependentTensorField>&, FPosition&, double&, const double&, const double&, int)’
/home/nico/code/FAnToM/src/visAlgos/IntegralLines/../../math/src/ODESolver/Tracer.hh:392:3: note: candidates are:
[... (diverse Vorschläge ausgelassen)]
/home/nico/code/FAnToM/src/visAlgos/IntegralLines/../../math/src/ODESolver/Tracer.hh:886:1: note:                 Tracer<DIM, lineT>::Tracer(std::vector<MeshNode>&, Tracer<DIM, lineT>::Fieldtype, const FPosition&, double, double, double, unsigned int) [with int DIM = 2, FLineType lineT = (FLineType)0u, Tracer<DIM, lineT>::Fieldtype = boost::shared_ptr<const FTimeDependentTensorField>, FPosition = FArray]

Die­se Mel­dung ist aus einem ganz bestimm­ten Grund fies, der aber nicht offen­sicht­lich ist. Die Mel­dung sug­ge­riert, man habe beim Funk­ti­ons­auf­ruf etwas falsch­ge­macht. Oft stimmt das auch und die Grün­de sind dann sol­che:

  • Para­me­ter der Funk­ti­on ver­ges­sen
  • bei einem (oder meh­re­ren!) Para­me­tern den fal­schen Typ benutzt
  • const igno­riert
  • Tipp­feh­ler

Ich habe über­legt, was davon es sein könn­te. Gegrü­belt und getes­tet. Man fängt ja nach ner Wei­le an, die unmög­lichs­ten Din­ge zu ver­mu­ten. Zum Bei­spiel, dass es viel­leicht dar­an, dass ein Para­me­ter const oder eine Refe­rence ist? Habe ich Tem­pla­tes falsch benutzt? Gera­de für Anfän­ger, die mit const­ness, Refe­ren­zen und Tem­pla­tes noch nicht so firm sind, der Super-Gau!

Aber auch mir ist es heu­te pas­siert.

Es lag dar­an, dass ich die Datei, in der die Funk­ti­on deklariert/definiert ist, nicht inclu­det habe.

Thema: Sezierte C++-Käfer | Beitrag kommentieren

Linker-Fehler und c++filt

Dienstag, 30. November 2010 | Autor:

Lin­ker-Error sind aus zwei Grün­den ekel­haft:
Ers­tens: Sie sind kryp­tisch sind, viel kryp­ti­scher als Com­pi­l­er­feh­ler (ja, das geht).
Zwei­tens: Sie tre­ten unter Umstän­den erst zur Lauf­zeit auf.

Bei­spiel:
could not load plugin './algoStore/visAlgoslibStreakSurface.so' :./algoStore/visAlgoslibStreakSurface.so: undefined symbol: _ZN23FStreakSurfaceAlgorithm10split_edgeESt4pairI6FArrayS1_E

Okay, undefined symbol - da haben wir wohl irgend­et­was dekla­riert, aber nicht defi­niert1. Aber was genau haben wir nicht defi­niert?
_ZN23FStreakSurfaceAlgorithm10split_edgeESt4pairI6FArrayS1_E?
Manch­mal kann man erra­ten, was gemeint ist, da die Namen der invol­vier­ten Funk­tio­nen, Klas­sen, Varia­blen in dem Wust irgend­wo drin ste­hen. Aber eben nur manch­mal. Die Lösung die­ses Pro­blems lau­tet c++filt!

c++filt ist ein klei­nes Tool, das einem die Sym­bol­na­men ent­zif­fert! („demang­led”). So wird’s benutzt:

> c++filt _ZN23FStreakSurfaceAlgorithm10split_edgeESt4pairI6FArrayS1_E
FStreakSurfaceAlgorithm::split_edge(std::pair<FArray, FArray>)
>

und schon ken­nen wir den Klar­na­men des Sym­bols! Ein­fach toll - ich wünsch­te, ich hät­te die­ses Tool schon frü­her gekannt!

  1. Dekla­ra­ti­on = „Es gibt die­se und jene Funk­ti­on!” Bsp: void funktion(double k); Dekla­ra­tio­nen ste­hen typi­scher­wei­se in Hea­der-Files. -- Definition/Implementation = „Die Funk­ti­on tut die­ses hier.” Bsp: void funktion(double k){ return 1./(k+1); } -- Man beach­te, dass die Dekla­ra­ti­on wirk­lich eine rei­ne Exis­tenz­be­haup­tung ist und erst die Defi­ni­ti­on das Ver­hal­ten der Funk­ti­on defi­niert, d.h. den Code ent­hält, den die­se aus­führt.

Thema: Programmieren | 4 Kommentare