C++Guns – RoboBlog

27.07.2011

+notiz

Filed under: — Thomas @ 17:07

QGIS usage
----------

Netzlogik

* Fehlenden Haltungen / Unterbrechungen
Haltungsfilter "Z1" <> 0 and "AB" < 1000 and "EntwaesArt" <> 'KR'

* Alleinstehende Haltungen
Haltungsfilter: "Z1" = 0 and "AB" < 1000 and "EntwaesArt" <> 'KR'

* Länge ungewohenlich
Haltungsfilter: "L [m]" > ($length + 5)

* Weitere komische Stellen
regexp_match( "SchBezUnte", '[A-Z]' ) and "AB" < 1000 and "Z1" <> 0 and "EntwaesArt" <> 'KR'

* Fehlerhafte Sohlhoehen
"HSA [NN]" + "B [cm]"/100 + 0.1 > "HD [NN]"

* Negtives Gefaelle
"HSA [NN]" < "HSE [NN]" -0.03 Kataster * Gebäude/Flurstuecksfragmente $perimeter / sqrt($area) > 20

MPI Debug
---------
WIth OpenMPI
mpiexec -n 16 xterm -e gdb -ex "run" --args /home/kater/bin/inka_kopplung Merck_12_01.dat

https://www.open-mpi.org/faq/?category=tuning#setting-mca-params
https://www.open-mpi.org/faq/?category=debugging
export OMPI_MCA_mpi_abort_print_stack=1
export OMPI_MCA_mpi_abort_delay=-1

GIT
---
Einen Ordner mit SHA1 commit ID auschecken. Relative Pathangabe fuehrt zu
error: pathspec 'examples_detlev/regtests/1/' did not match any file(s) known to git.
Daher mit ../ umgehen.
git checkout 43840083a13cb3781bf3739666b94a64e45e8e63 ../regtests/8
Für SHA ID entweder gitk oder
regtests$ git log --follow 8
Vllt hilft auch ein
git fetch ?

Convert surver DGM to XYZ
for i in *.grd; do gdal_translate -of XYZ $i output/$i.xyz; done

mencoder "mf://*.jpg" -mf fps=2 -o video.avi -ovc lavc -lavcopts vcodec=mpeg4
mplayer -ao pcm:fast:file=audio.wav -vo null -vc null video.avi
lame -V0 -q0 --vbr-new audio.wav audio.mp3

ogr2ogr -f "ESRI Shapefile" -where "GEB_ART <> 'G2363'" test.shp ../frankfurt/SGK_Shape_2012/GEBAEUDE.shp
ogr2ogr -f "ESRI Shapefile" -where "OBJEKTART = '2500'" wasserspiegel.shp 2475340000_VG_000_LAENGS_LMZ.shp

#
# -Wextra This are some extra warning flags that are not enabled by -Wall
#
# Enable this tests from time to time
#
# -Wsuggest-attribute=const Warn about functions that might be candidates for attributes const.
# -Wsuggest-final-types Warn about types with virtual methods where code quality would be improved if the type were declared with the C++11 final specifier
# -Wsuggest-final-methods Warn about virtual methods where code quality would be improved if the method were declared with the C++11 final specifier
# Use -Wsuggest-final-types. Use link time optimization for both.
# -Weffc++ Warn about violations of the following style guidelines from Scott Meyers' Effective C++ series of books
# -Wdouble-promotion Give a warning when a value of type float is implicitly promoted to double.
# -Wconversion Warn for implicit conversions that may alter a value
# -Wzero-as-null-pointer-constant Warn when a literal '0' is used as null pointer constant.
# -Wlogical-op Warn about suspicious uses of logical operators in expressions.
# -Wpadded Warn if padding is included in a structure
# -Wredundant-decls Warn if anything is declared more than once in the same scope
# -Wvector-operation-performance Warn if vector operation is not implemented via SIMD capabilities

# link time optimazion
#QMAKE_CXXFLAGS += -flto
#QMAKE_LFLAGS += -flto


# The QT library is not free of warnings. If we enable e.g. -Wconversion we see a lot
# of warnings from Qt we cant fix nor care. Here is a simple way to disable warnings
# for external framwork. Just  include library headers using -isystem instead of -I.
# This will make them "system headers" and GCC won't report warnings for them.
# This still trigger some warnings due to inline of code
QMAKE_CXXFLAGS += -isystem[QT_INSTALL_HEADERS]/QtCore
QMAKE_CXXFLAGS += -isystem[QT_INSTALL_HEADERS]/QtGui
QMAKE_CXXFLAGS += -isystem[QT_INSTALL_HEADERS]/QtNetwork
QMAKE_CXXFLAGS += -isystem[QT_INSTALL_HEADERS]/QtOpenGL
QMAKE_CXXFLAGS += -isystem$$[QT_INSTALL_HEADERS]/QtScript

fast todo
* dctor base class virtual
* ctor mit default arg explicit
* const getter die pointer zurückgeben auch pointer const machen, wenn die klasse owner vom object ist.

@@ -586,6 +586,7 @@ void DomainController::setRotateSelectionMode(bool enabled) {
connect(d->rotationDialog, SIGNAL(accepted()), this, SLOT(acceptRotation()));

connect(d->rotationDialog, SIGNAL(angleChanged(qreal)), d->helper, SLOT(setAngle(qreal)));
+ connect(d->rotationDialog, SIGNAL(angleChanged(qreal)), d->helper, SLOT(updateRotateItem())); << unnötig unused funktion parameter @@ -39,10 +43,10 @@ RotationDialog::~RotationDialog() /* * redirect of signal slot int / double problem */ -void RotationDialog::sliderChanged(int n) +void RotationDialog::sliderMoved(int) { - ui->doubleSpinBox_Angle->setValue(n);
- emit angleChanged(n);
+ ui->doubleSpinBox_Angle->setValue(ui->horizontalSlider->value());
+ emit angleChanged(ui->horizontalSlider->value());
}

Domainview kennst polynodes. richtig so?
+#include "GraphicsPolyNodeItem.h"

GUI
- Projekt/File open Window mit extraspecial Optionen (steht iwo im Notizbuch)
- Sowas wie eine Lupe definieren. Extra (Rechner) Windows was irgendwas beobachtet. Bereiche im Netz? Files auf externen Rechnern?
- Im Debug/About Window (Notizen siehe irgendwo anders (Pidgin)) die Ausgabe von "file binary"

- Windows Statistics. Brauchen ein Plot. qwt geeignet?

- Wie bei gimp filter kleine vorher/nachher bilder vom mesh wenn man operationen darauf ausführt.

- googlemaps in gui bider und mesh drüber rendern

- QGraphicsGeoMap kann man das auch für nicht mobility devices nutzen?

- GraphicsNodeItems editmode beschreibt ne implementoerung
http://www.informit.com/articles/article.aspx?p=1405545&seqNum=4

GUI LIB
- Dynamic Mesh/ static ordered mesh.
Mit Quadtrees hatten wir ja starke Probleme. Warum nicht das Mesh nach X Coord sortiere wie in
double nodes check routine von aron. Punkt und Bereichsabfragen sind damit auch machbar. Wenn man y nicht mitsortiert
ist das auch nicht sonderlich aufwendig.
Es braucht noch ein mapping zur den nicht sortierten Daten um ueber die orignal Eingangsdaten zu iterieren.
NACHTEIL: Zu kleine Bereiche können erstmal nicht zu einem Polygon zusammengefasst werden(ideen?)

- Polygon Algo zum vereinfachen? http://130.83.152.138/temp/shape_matching_mobilesensing.png

- Teilmesh aus einem großes Mesh herauskopieren um Operationen darauf schneller durchführen zu können.
Select by Ele/node/rect. Oderandere select T1echniken iwo hier auf der Seite.

- Mesh über Netzwerk laden. Test mit Proxyadapter und Image statt Mesg. Client sagt welchen Bereich und Remote PC
rendert es und schickt es zurück. Alterantiv werden nur die Items in diesem Bereich zurückgeschickt.
Mit QCache cachen.

- Class ColoredMesh. Hält ein Image was kleiner ist als das Netz. XY der Nodes auf Pixel des Bildes mappen und pixel.counter erhöhen. counter dann auf farbe mappen. Danach sind schwarze Bereiche im Bild Inseln. So die Inseln bestimmen?
Erledigt 12.2013
parvisu. Der Rand wurde so recht gut bestimmt. Das Bild noch mit BV tools kurz nach bearbeiten (dilate) und pavlidis für die Kontur des Randes. Inseln finden sich nicht sehr gut, da kleine Inseln etwa so groß sind wie die Auflösung des Netzes.

- PatchIterator Zugriff auf alle angeschlossenen nodes und elements von allen nodes. Braucht es dazu abgeleitete nodes und mesh klassen?

- ElementIterator welcher ein Pointer auf das Nodearray hergibt,so dass man die nodeIDs aus den eementen rauszieht und access aufs node hat.
Erledigt mit ElementDekorator und spezielle Template Klasse Iterator fpr Elements.

- Mesh Statistics neue Klasse erstellen.
Angerungen welche Informationen bereit gestellt werden können hier: https://romeo.univ-reims.fr/documents/fluent/tgrid/ug/chp15.pdf

- Pattern Locator und Positions

Unwichtiges für die LIB
- Q_LIKELEY Q_UNLIKELEY

- Mesh Boundary Area - Sum Element Area = Insel Area. Berücksichtigt man noch die Insel Areas und bleibt weiterhin eine
große Differenz, dann hat man ein unbekanntes Loch oder vermaschte Inseln im Netz.

- Der Algo von Dijkstra findet die Länge des kürzesten Path von einem Knoten zu den andern. (Mit etwas Aufwand kann man auch den Path selbst mit abspeichern). Er benutzt die Kantenlängen dazu. Was ist, wenn man die Kantenlänge durch die Node IDs der Kante ersetzt? Findet er dann ein Path durchs Netz optimiert für Array Zugriffe, räumliche Datenlokalität?

- Sortierung ohne Topologie. Nur Anhand vom Elementcenter sortieren. Das unterste zuerst und dann das am nächsten.

- doppelte knoten finden mit HSet/QHash + MapReduce Hashing
ODER eine art fuzzy search für 2d punkte. möglicherweise sehr einfach indem man die letzten stellen der zahl abschneidet um so die unschärfe festzulegen. dann hashen.

Faster Code Todo
Memoization
http://en.wikipedia.org/wiki/Memoization
So eine Art cache. Genauerer Unterschied? Kann man wpmöglich für cadxy nutzen. C+ wrapper von 1998 mit paper http://apl.jhu.edu/~paulmac/c++-memoization.html

PETSc
PETSc's solver for block matrices PCFieldsplit http://www.mcs.anl.gov/petsc/petsc-3.3/docs/manualpages/PC/PCFIELDSPLIT.html#PCFIELDSPLIT is what you need. More information on fieldsplit is given in section 4.5 of the manual.

-------------------------------------------------------------------------
http://www.heise.de/ct/hotline/Linux-Prozesse-an-CPU-Kerne-binden-1002732.html
taskset -c 0-2 pelfe
Cache speed tests. Alle Threads auf eine CPU binden, valgrind TLB/Cache misses, nur ein thread pro cpu. Test für nur lesend, und einen für schreibend, so dass sich die threads gegenseitig aus dem cache werfen

-------------------------------------------------------------------------

You can run the code with '-info' - and look for 'stash' - that gives
the message lenghts that got commuicated for matrix assembly.

https://lists.mcs.anl.gov/mailman/htdig/petsc-users/2009-August/004937.html

>
> Okay, look at VecScatterBegin/End for 24 and 48 cores (I am guessing you
> have 4 16-core chips, but please figure this out).
> The messages are logged in ScatterBegin, and the time is logged in
> ScatterEnd. From 24 to 48 cores the time is cut in half.
> If you were only communicating the boundary, this is completely backwards,
> so you are communicating a fair fraction of ALL
> the values in a subdomain. Figure out why your partition is so screwed up
> and this will go away.
>
>
> What do you mean by "If you were only communicating the boundary, this is
> completely backwards, so you are communicating a fair fraction of ALL the
> values in a subdomain"?
>

If you have 48 partitions instead of 24, you have a larger interface, so
AssemblyEnd() should take
slightly longer. However, your AssemblyEnd() takes HALF the time, which
means its communicating
much fewer values, which means you are not sending interface values, you
are sending interior values,
since the interior shrinks when you have more partitions.

What this probably means is that your assembly routines are screwed up, and
sending data all over the place.

https://lists.mcs.anl.gov/mailman/htdig/petsc-users/2012-October/015401.html

Openseamap

  1. Einige Karten runterladbar. Im Browser kann man aber die ganze Welt anzeigen lassen. Wie kommt man an die restlichen Karten?
  2. Karten in verschiedenen Formaten erhältlich
    • KAP non Maptech BSB/KAP
      A BSB image file has a .KAP extension and can be optionally accompanied by a .BSB file which stores further cartographic data and relates multiple .KAPs together. libbsb is a portable C library for reading and writing BSB format image files. Typically used for nautical charts, BSB charts use the .KAP or .CAP extension and store cartographic information in addition to a run-length encoded raster image. A number of utilities to convert and work with BSB charts are included in the libbsb package. e.g. bsb2tif - convert BSB image to TIFF format. The BSB file format stores raster image data in a run-length encoded binary form along with ASCII text describing the projection, datum and other information necessary for GIS application
    • WCI SeaClear
      SeaClear is a PC based chart plotter for Windows.
    • PNG Bilddatei (randlos)
    • JPR Fugawi Kalibrierungsdatei
      Need more research http://www.fugawi.com/web/support/utilities_and_docs/utilities_index.htm
    • CAL TTQV Kalibrierungsdatei
      Touratech QV (auch TTQV, Abkürzung für Touratech Quo Vadis) ist der Markenname der GPS-Software des Unternehmens Touratech AG. Touratech QV unterstützt die Tourenplanung durch das Laden von Wegpunkten, Routen und Tracks auf oder vom GPS-Empfänger und ermöglicht Echtzeitnavigation zu Land, Wasser und Luft. Touratech QV unterstützt das Scannen und Kalibrieren eigener Landkarten. Touratech QV läuft auf Windows PC. Voraussetzung ist ein NMEA oder Garmin-Protokoll kompatibler-GPS-Empfänger.
    • KMZ Keyhole Markup Language (KML gezippt) Import für Garmin oder Google
      Keyhole Markup Language (KML) ist eine Auszeichnungssprache zur Beschreibung von Geodaten für die Client-Komponenten der Programme Google Earth und Google Maps. KML befolgt die XML-Syntax und ist ein Standard des Open Geospatial Consortium.
      Als geodätisches Referenzsystem wird in KML-Dokumenten ausschließlich das World Geodetic System 1984 verwendet, d.h. sämtliche Koordinaten werden mit geografischer Länge und Breite sowie, falls vorhanden, Höhe über Meer angegeben. Die Höhe bezieht sich dabei auf das WGS84 EGM96 Geoid.
      Neben Google Earth unterstützt das freie KDE-Programm Marble ebenfalls das KML-Format zur Routenbetrachtung,

Bevorzugtes Format wird woh KML sein.

Openstreepmap

http://wiki.openstreetmap.org/wiki/Main_Page
Woher kommen die Daten? GPS, Luftbilder, Karten, Daten im XML Format erhältlich.

XML Pros:
* human readable cause of clear structure
* machine independent cause of exact definitions e.g. charactersets, XML schema definitions, DTD,¿
* ready to use parsers for general XML that can be customized for a concrete file format
* good compression ratio

XML cons:
* very huge files
* might need to decompress before
* parsing takes a lot of time

Es gibt zusätzlich zu sämtlichen Wegen/Strassen, Hochspannungsnetze und Luftbilder. Häfen, Seekarten und Gewässer sowie Bauwerke und Einrichtungen im Zusammenhang mit Gewässern.
Es gibt teilweise detailierte Informationen über die Art des Gewässers/Fluss, verschiedene Häfen, Strand, Hafenmauer bis hin zu Telefonzellen, Spielplätzen, Toiletten, Parkplätzen und Fischbrötchenbuden.
Neben OpenStreetMap gibt es OpenSeaMap, welches Wassertiefen und sonstige Seezeichen enthält.

Es existiern viele Softwareprojekte mit denne die Daten gerendert oder geändert werden können.

googlemap:
Lizensprobleme. Daten dürfen nicht frei benutzt werden.

Küstenlinien mittels Bildverarbeitung ermitteln:
Sehr aufwändig und fehleranfällig. Die Ausgaben des Algorithmus müssen kontrolliert werden. Es werden keine Informationen gewonnen die man nicht schon durch Openstreetmap bekommen könnte. Das wäre ehr was für ne Bachelorarbeit ^^

gis:
Geo Informations System
geotiff: kombination eines Bildes mit geographischen Daten. Quasi Standard. Bildinformation mit jedem Programm darstellbar.

http://trac.osgeo.org/geotiff/ Library zum einlesen und erstellen von geotiff Datein.
apt-get install libgeotiff-dev geotiff-bin

Programm qlandkarte zum anzeigen von diversen Karten
http://sourceforge.net/apps/mediawiki/qlandkartegt/
apt-get install qlandkartegt

GUI

Ja hier geht es um das Programm mit der Benutzeroberflaeche worueber wir auch geredet haben.
Ich hab noch kein gescheiten Namen dafuer. SELFEcontrol oder so?
Werd demnaechst erstmal Infos sammeln was genau es koennen soll. Umso leicher ist es zu programmieren.
Drei Teilprogramme werden auf jeden Fall integriert.

Namelist Editor

Der Namelist Editor ist zu 90% fertig. Es fehlen noch paar Schoenheitskorrekturen und ich muss das
Programm mal in Benutzung von andern Usern sehen. Sonst tut es das was es soll.
svn co https://fortrannamelist.svn.sourceforge.net/svnroot/fortrannamelist fortrannamelist

Todo:
neuer Check: Simulations Start- Endzeiten ueberpruefen

Visualisierung

Mein Visualisierungsprogramm hatte ich Anfang des Jahres komplett neu geschrieben und es "katerFEMpresenter"
getauft. Es gibt zwar noch etliche Ideen die ich einbauen will, aber im grossen und ganzen ist es
schon gut benutzbar um Netze anzuzeigen.

Features

- beliebig viele Netze laden
- besonders grosse Netze koennen mit der "minimal" Funktion besonders RAM sparend geladen werden
- Elemente, Nodes oder Tiefen colorieren
- Kanten des Netzes darstellbar
- Element oder Node Nummer darstellbar
- Graph des Netzes darstellbar
- sceenshot funktion
- Elemente mit der Maus Markierbar und deren Daten als Tabelle anzeigen
- "gehe zu" Element-, Node Nummer
- Zoom Funktion

Welches Features geplant sind

- remote Netze laden: man ist z.B. am CLuster eingeloggt und will sich ein Netz laden.
Forwarding von X ist langsam. Besser die Node und Element Daten auf den Client Rechner
kopieren und dort rendern.

- neuere OpenGL nutzen: Momentan benutze ich sehr alte und langsame Techniken um das Netz
zu rendern. OpenGL Ver. 3 bietet Techniken um grosse Daten sehr viel schneller zu rendern.
Parallel dazu plane ich nur den Qt eigenen Renderer ohne OpenGL zu nutzen, da es doch recht
viele Linux Rechner ohne 3D Graphik Treiber gibt.

- Webpage mit Screenshots und Beschreibung erstellen

- und noch vieles mehr 😀

libkater
Features

- Laden, speichern (plaintext und binaer) von Netzen
- sortieren von Netzen
- FORTRAN Interface
- finden von Inseln und Randknoten
- erstellen von Nachbarsbeziehungen zwischen Knoten, Kanten und Elemente
- finden von Knoten und Elemente anhand von X Y Koordinaten (katerSuche)

geplante Features

- Code von Altlasten entfernen und den Programmierstyle verbessern. (Ich hab in den letzen
2 Jahren viel gelernt wie man ein groesseres Softwareprojekt schreibt)

- Segmentation Fault und floating point exception (divison through zero) Fehler abfangen und die
wichtigsten Variablen ausgeben. Dieser Bugreport kann mir dann per Mail geschickt werden.

- Doku auffrischen und Beispiele erstellen wie man die lib nutzt

- lib Qt tauglich machen, so dass aus Qt Programme mit der LIB gescheit kommuniziert werden kann

- Test fuer die Flaeche des Dreieckes.
Test Laenge Seite kleiner als Summe Seiten/2
Test Laenge Seite ungleich 0
Test Laenge/Flaeche im Verhältnis Number??
Test schreiben fuer adj Matrix accuracy??
Test Adressen der Variablen merken/Vergleichen

- katersuche ueberdenken. Die Suche ist auf maximale Schnelligkeit ohne Ruecksicht auf RAM Verbrauch
ausgelegt. Ich plane eine zweite geometrische Suche anhand von R-Trees einzubauen, die deutlich
weniger RAM verbraucht und dennoch gut schnell ist. Die Initialisierungszeit verkuerzt sich dann auch.

Wichtig ist auch, dass die Suche mit dem Rendertechniken kombiniert werden kann. Denn um ein Netz
mit Millionen Knoten rendern zu koennen werden aehnliche Speicherstruckturen wie die katerSuche erstellt.
Hier muss man die Daten ja nicht doppelt speichern.

wichtige interne Ändeurngen
- eigene Gleitkommavariable definieren und im ganzen Projekt nutzen, um wenn nötig zwischen float, double und long double zu wechseln

- eine andere Gleitkommagenauigkeit zum speicher als zum rechnen nehmen. Zur Laufzeit wechseln? Spart die Hälfte an RAM, aber die Rechengenauigkeit kann bleiben.

- md5 hast der adressen wichtiger variablen machen um sie im fehlerfall zu verifizieren. segfault vorher abfangen

- union zum speicher der xyz daten. getrennt in gleitkomma oder als array, so dass man sie schneller lesen kann aus ner biaerd datei. oder so dass man sie wie ein array behandeln kann

- OO Struktur. Grundriss :
class CMeshData
{
x, y, z
}

class CMesh
{
CMeshData meshdata

load(string filename)
}

CMesh::load(string filename)
{
CMeshReader(filename, format).read(meshdata)
}

CMeshReader::read()
{
readerData.create CMeshIOHandler()
readerData.handler.read(meshdata)
}

class CMeshIOHandler
{
check for a handler that can handle the file
}

class CWabauPlainHander :: CMeshIOHandler
{
}

class CWabauBinaerHander :: CMeshIOHandler
{
}

class CNetCDFHandler :: CMeshIOHandler
{
}

polygon

Einlesen der polygon.dat und darstellen, verschieben und interpolieren der Knoten.

- es funktioniert das Darstellen und verschieben Handgesetzer Punkte

- zwischen den Punkten wird eine kubische Bezierkurve interpoliert.
Es ist garantiert dass die Interpolierte Line durch die vom User
vorgegebenen Punkte geht. Die Benutzung von kubischen Bezierkurven
statt quadratische bringt einige Vorteile. Eine gezeichnete Parabel kommt
von oben links und geht nach oben recht. Ein Polygon 3. Grades kommt
von oben links und geht nach unten recht, kann aber auch nach oben
rechts gehen. Das funktioniert, weil man bei
f(x) = ax^3 + bx^2 + cx +d den Paramater a = 0 setzt kann. Das ergibt
die Gleichung einer Parabel.
http://130.83.152.138/temp/interpolated.jpg Versuch 1
http://130.83.152.138/temp/interpolated2.jpgVersuch 2
Vllt. Verwendung einer externen LIB die B-Splines erzeugen kann.

- mal diesen spline algo ausprobieren http://www-lehre.informatik.uni-osnabrueck.de/~cg/2002/skript/node59.html

- Herausfinden bei wieviel Knoten Qt schlapp macht. In der Doku sagen die, dass man viele 2D Items darstellen kann und haben ein beispiel mit 40000 Items.

Was ich noch nicht ganz klar vor mir sehe:
- irgendwie mit geo Daten kombinieren.
- Die Interpolierten Polygone wieder als polygon.dat abspeichern?
- Und die interpolierten Polygone bzw. die eingelesenen aus der polygon.dat sollen sowohl ueber einem Bild
als auch ueber einem Netz darstellbar sein.
Oder soll ein Bild, darauf das Netz und darauf das Polygon dargestellt werden? Und das mit millionen von
Knoten?

Allgemeine Programmiertipps für schnellere Programme
Sprünge sind teuer. Vermeide es wild umher zu springe. Vermeide es überhaupt zu springen. Es können keine Befehle vorraus
berechnet werden, wenn durch einen Sprung plötzlich woanders gerechnet wird.
Schleifen die lange laufen sind gut. Wenn 100mal zum Schleifenanfang gesprungen wurde, wird das wohl auch beim 101. Mal
passieren: Sprungvorhersage funktioniert.

Vermeide Sprünge in Schleifen. Z.B. so nicht:

Schleife über alle Knoten
Schleife über alle Richtungen
Schleife über alle Frequenzen
if petsc then petscSolver
else otherSolver

Besser:

if petsc then
Schleife..
Schleife..
Schleife..

else
Schleife...
Schleife...
Schleife...

Funktions argument nonnull nutzen um den compiler zu sagen, dass
pointer niemals NULL sind. siehe auch http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

Diverse Notizen

Die Schleifeninvariante enthält Aussagen darüber, was vor und nach jeder Iteration gilt. Das heißt, inkonsistente "Kraut-und-Rüben-Zustände" mitten in einer Iteration werden übersprungen, und nur der konsistente Zustand außerhalb der Iterationen wird beschrieben. Die Schleifeninvariante soll zusammen mit der Abbruchbedingung beweisen, dass das Ergebnis des Algorithmus korrekt ist, falls der Algorithmus terminiert. Das heißt, sie muss alles enthalten, was für dieses Ziel gebraucht wird.

Die Schleifenvariante enthält hingegen Aussagen darüber, was sich durch eine Iteration verändert, also worin der Unterschied zwischen dem Zustand nach i-1 Iterationen und dem Zustand nach i Iterationen besteht. Die Schleifenvariante soll zusammen mit der Abbruchbedingung beweisen, dass der Algorithmus terminiert. Das heißt, sie muss alles enthalten, was benötigt wird um einzusehen, dass der Algorithmus sich Schritt für Schritt der Abbruchbedingung nähert.

No Comments »

No comments yet.

RSS feed for comments on this post. TrackBack URL

Leave a comment

You must be logged in to post a comment.

Powered by WordPress