|
|
|
|
A.h
|
Code: |
struct cell {
int counter;
};
typedef struct cell Cell; |
|
A.c
|
Code: |
Cell cells[args.X_arg][args.Y_arg][args.Z_arg];
createCells(sites, cells, args.X_arg, args.Y_arg, args.Z_arg, args.nsites_arg, args.llength_arg, 3.0); |
|
B.c
|
Code: |
void createCells(Site * sites, Cell *** cells, int x, int y, int z, int nSites, float a, float rc); |
|
/e: Übrigens glaube ich ist es nicht ganz so, dass mein 3D Array ein Array von Pointern auf Pointer auf Pointer ist, sondern nur die erste Dimension dürfte aus Pointern bestehen. Irgendwie so hieß es in dem C Buch von galileo computing.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von OliOli am 06.02.2011 21:35]
|
|
|
|
|
|
Hmm, bin davon ausgegangen dass sich das so überträgt, hab aber offen gesagt noch nie Arrays von größerer Dimension als 1 so von Hand deklariert
Wobei ich ja immernoch neugierig bin, wie du es schaffst zur Laufzeit so ein Array zu deklarieren, war eigentlich der Überzeugung das geht nicht.
Was spricht gegen malloc und direkt mit Pointern arbeiten?
|
|
|
|
|
|
|
| Zitat von _abyss
Wobei ich ja immernoch neugierig bin, wie du es schaffst zur Laufzeit so ein Array zu deklarieren, war eigentlich der Überzeugung das geht nicht.
| |
Wie meinst du das? Habe den Code doch gepostet... Mehr gibts da nicht zu sehen. Das ganze findet in der main() Funktion statt.
| Zitat von _abyss
Was spricht gegen malloc und direkt mit Pointern arbeiten?
| |
Ehm... Ich glaube so hab ichs bei nem 1D Array gemacht, wenn du ungefähr das hier meinst:
|
Code: |
Site *s;
s = malloc(n * sizeof (Site)); |
|
Aber wie ich das auf nen 3D Ding abstrahiere ohne es, wie schon vorgeschlagen wurde, auf ein 1D Array zu mappen, war mir schleierhaft.
|
|
|
|
|
|
|
Ich hab bis eben noch gedacht, C lässt in Array deklarationen nur literale zu - habe mich gerade aber eines besseren belehrt.
Alternativ zum mappen auf ein 1D array kannst du einfach Arrays schachteln. Also
|
Code: |
double **array;
array = malloc(sizeof(double*)*n_1);
for(i=0; i<n_1; i++) {
array[i] = malloc(sizeof(double)*n_2);
}
|
|
und mit array[i][j] zugreifen.
Edit: Was halt zum Problem passt. Im Moleküldynamik Code hier am Institut wird alles in ein-dimensionalen Arrays gespeichert um den gleichen Code hinterher mit entsprechenden Mapping Makros für Probleme in 2D und 3D benutzen zu können.
Die Strömer hingegeben haben quasi nur 3D Code und benutzen Arrays die der Geometrie dessen was gespeichert wird entsprechen.
|
[Dieser Beitrag wurde 3 mal editiert; zum letzten Mal von _abyss am 06.02.2011 22:02]
|
|
|
|
|
|
Hi,
meine Freundin muss folgende Aufgabe lösen und ich hab keinen Schimmer, wie das gehen könnte:
Zeigen Sie, dass immer die Endziffer 6 hat.
Noch eine Aufgabe lautet:
Zeigen Sie, dass gilt:
Hat jemand die Lösungen, oder Tips, wie man das beweist?
Google bringt mich nicht wirklich weiter. Da heißts nur, wegen ist die Endziffer immer 6. Das leuchtet mir nicht wirklich ein.
Die Aufgaben gehören zum Thema "vollständige Induktion"
|
|
|
|
|
|
|
| Zitat von ChrissKL
Zeigen Sie, dass gilt:
| |
Ich denke mal, dazu gehört noch die Voraussetzung .
Anfang für n=1 passt.
/e: Wieso gibt's keine Zeilenumbrüche?
6^(n+1)=6^n * 6, 6^n Endziffer 6 ist deine Voraussetzung.
|
[Dieser Beitrag wurde 6 mal editiert; zum letzten Mal von Irdorath am 06.02.2011 22:34]
|
|
|
|
|
|
|
|
|
|
| Zitat von ChrissKL
Hi,
meine Freundin muss folgende Aufgabe lösen und ich hab keinen Schimmer, wie das gehen könnte:
Zeigen Sie, dass immer die Endziffer 6 hat.
Hat jemand die Lösungen, oder Tips, wie man das beweist?
Google bringt mich nicht wirklich weiter. Da heißts nur, wegen ist die Endziffer immer 6. Das leuchtet mir nicht wirklich ein.
Die Aufgaben gehören zum Thema "vollständige Induktion"
| |
Die niederwertigste Stelle wird wieder durch 6*6 gebildet und ergibt deshalb wieder ne 6 an ebendieser Stelle im Ergebnis.
Hoffe es ist klar, was ich meine.
|
|
|
|
|
|
|
| Zitat von ChrissKL
Hi,
meine Freundin muss folgende Aufgabe lösen und ich hab keinen Schimmer, wie das gehen könnte:
Zeigen Sie, dass immer die Endziffer 6 hat.
Hat jemand die Lösungen, oder Tips, wie man das beweist?
Google bringt mich nicht wirklich weiter. Da heißts nur, wegen ist die Endziffer immer 6. Das leuchtet mir nicht wirklich ein.
| |
Ganz einfach: 6^1 hat hinten immer eine 6 (logisch ). Multiplizierst du es mit 6 hat du 36, was wiederum hinten einer 6 hat. 6 * 36 = 6*30 + 6*6. 6 * 30 hat hinten eine 0 und wenn du da die schon bekannten 6*6=36 drauf addierst, hat du an letzter Stelle 0+6 was wiederum 6 ist.
Das musst du jetzt nur noch irgendwie hübsch mathematisch schreiben
|
|
|
|
|
|
|
Ja, sorry. Meine Freundin hat mir die eine Aufgabe falsch diktiert. Es ist die bernoullische Ungleichung. Ja, es kam mir gleich bekannt vor.
Strikte Ungleichung sagt Wiki zur Version mit > statt >=.
In ihrer Aufgabenstellung sind keine Einschränkungen gegeben, also muss sie die wohl selbst finden. Nur wie?
Der Beweis im Wiki will mir gerade nicht ganz einleuchten. Was passiert da denn mit dem ?
Vollständige Induktion war noch nie mein Lieblingsthema, zur HM1 hab ich das super drauf gehabt, aber mittlerweile fehlt mir wieder irgendein Gedankenblitz...
------------------------------------------------------
x87: Was meinst du denn mit "niederwertigste Stelle? Klar ists mir leider nicht.
¤: Zwipos können auch toll sein
| Zitat von Achsel-des-Bösen
Ganz einfach: 6^1 hat hinten immer eine 6 (logisch ). Multiplizierst du es mit 6 hat du 36, was wiederum hinten einer 6 hat. 6 * 36 = 6*30 + 6*6. 6 * 30 hat hinten eine 0 und wenn du da die schon bekannten 6*6=36 drauf addierst, hat du an letzter Stelle 0+6 was wiederum 6 ist.
Das musst du jetzt nur noch irgendwie hübsch mathematisch schreiben
| |
Danke, aber da ich kein Mathematiker bin, wie drückt man das perfekt aus?
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von ChrissKL am 06.02.2011 23:04]
|
|
|
|
|
|
| Zitat von OliOli
| Zitat von _abyss
Wobei ich ja immernoch neugierig bin, wie du es schaffst zur Laufzeit so ein Array zu deklarieren, war eigentlich der Überzeugung das geht nicht.
| |
Wie meinst du das? Habe den Code doch gepostet... Mehr gibts da nicht zu sehen. Das ganze findet in der main() Funktion statt.
| Zitat von _abyss
Was spricht gegen malloc und direkt mit Pointern arbeiten?
| |
Ehm... Ich glaube so hab ichs bei nem 1D Array gemacht, wenn du ungefähr das hier meinst:
|
Code: |
Site *s;
s = malloc(n * sizeof (Site)); |
|
Aber wie ich das auf nen 3D Ding abstrahiere ohne es, wie schon vorgeschlagen wurde, auf ein 1D Array zu mappen, war mir schleierhaft.
| |
soweit ich jetzt grad mal wieder nachgelesen hatte(hatte das auch schonmal gebraucht, bin dann glaub ich auf vektoren umgestiegen)
müssen alle bis auf die erste Dimension eines multi Arrays Konstant sein.
Dh=> wenn du alle dim zur Laufzeit definieren willst 1dim
sonst
|
Code: |
struct cell {
int counter;
};
typedef cell(*cellArray)[5][5][5];
void createCells(cellArray cells){
(*cells)[1][2][3].counter = 6;
}
int main (){
cellArray x = (cellArray)new cell[5][5][5];
createCells(x);
std::cout << (*x)[1][2][3].counter << "\n" ;
return 0;
} |
|
e: vllt hilft auch der link bisl weiter
http://www.lysator.liu.se/c/c-faq/c-2.html
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Drengidal am 06.02.2011 23:34]
|
|
|
|
|
|
Öhm. Ich soll die Norm einer Wellenfunktion ausrechnen. Den Raum hab ich vorher diskretisiert und kenne alle Werte der Welle an allen diskreten Punkten im Raum. Wie sieht dann die Norm aus?
¤: Ich diskreditiere zwar auch Räume, aber in dem Fall diskretisiere ich sie doch wohl eher
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von RichterSkala am 07.02.2011 5:43]
|
|
|
|
|
|
Über das Betragsquadrat der Funktion an allen Punkten summieren und die WF dann durch die Wurzel (?) dieser Summe teilen.
===
So, ich krieg die Krise hier.
Ich habe mich entschieden, das Array auf ein 1D array runterzukochen, Hauptargument war dass die Abstraktion auf 1D oder 2D dann einfacher ist.
Ich hab mir folgende Funktion geschrieben:
|
Code: |
Cell *
getCell(Cell * cells, int x, int y, int z, int X, int Y, int Z)
{
if(x >= X || y >= Y || z >= Z)
{
printf("Array indices out of bound.\n");
exit(1);
}
return *cells[(x * Y + y) * Z + z];
} |
|
x,y und z sind die gewünschten Indizes, X,Y und Z die Größe der Dimension.
Das Ding ist, ich will mit dieser Funktion nicht die gewünschte Cell kopieren und zurückgeben, sondern einen Zeiger auf das gewünschte Element, da ich den Eingabeparameter cells anschließend verändern will. Sagen wir also, ich will sozusagen cells[1][2][3].counter = 0 setzen, dann würde ich sowas wollen:
getCell(cells, 1, 2, 3, 10, 10, 10).counter = 0;
Und jetzt wurde das Element an seinem ursprünglichen Speicherort bearbeitet.
Daher gebe ich in der Funktion oben nen Pointer auf das Element zurück. Funktioniert leider nicht mit der Meldung:
error: invalid type argument of ‘unary *’
-------
Hah, es funktioniert mit
return &cells[...];
Wo ist der Unterschied zu *???
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von OliOli am 07.02.2011 13:07]
|
|
|
|
|
|
| Zitat von OliOli
error: invalid type argument of ‘unary *’
| |
dann gib keinen Pointer zurück sondern eine Referenz.
Wenn du nen Pointer zurückgibst musst du den auch vor dem Zugriff nocheinmal dereferenzieren
(*getCell(...)).counter = 0
einfach
Cell &
sollte es in C auch geben oder?
¤:
Der Unterschied liegt darin
dass für den Compiler * ein Pointer ist also die Adresse zu diesem Pointer(wo drin dann die Adresse zu dem worauf er zeigt steht)
und & ist direkt die Adresse auf das Object.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Drengidal am 07.02.2011 13:10]
|
|
|
|
|
|
Musst die Rückgabe ohne Stern machen, also
return cells[(x * Y + y) * Z + z];
die Variable cells hast du ja als Pointer definiert. Kannst du einfach normal wie eine andere Variable behandeln.
|
|
|
|
|
|
|
Ist der Gradient = die Ableitung? Ich sehe die ganze Zeit im Numerik-Buch dieses "Dreieck" aka Gradient und es verhält sich irgendwie immer wie die Ableitung. Also ist Gradient = Ableitung?
|
|
|
|
|
|
|
Was soll eigentlich diese Index-Bestimmung?
Wenn du versuchst auf das Element 10,10,10 zuzugreifen, dann erhältst du mit (x * Y + y) * Z + z = 1110, hast jedoch nur 1000 Elemente.
¤\Gradient == totale Ableitung, also ein Vektor, der aus allen Richtungsableitungen besteht.
Hyp
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von Hyperdeath am 07.02.2011 13:16]
|
|
|
|
|
|
| Zitat von Gepan.3dsvs.com
Ist der Gradient = die Ableitung? Ich sehe die ganze Zeit im Numerik-Buch dieses "Dreieck" aka Gradient und es verhält sich irgendwie immer wie die Ableitung. Also ist Gradient = Ableitung?
| |
Gradient ist die Summe der partiellen Richtungsableitungen.
Will sagen: in nur einer Dimension ist der Gradient gleich der Ableitung.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Tony.50 am 07.02.2011 13:16]
|
|
|
|
|
|
| Zitat von Hyperdeath
Was soll eigentlich diese Index-Bestimmung?
Wenn du versuchst auf das Element 10,10,10 zuzugreifen, dann erhältst du mit (x * Y + y) * Z + z = 1110, hast jedoch nur 1000 Elemente.
Hyp
| |
Ne, denn Cell cells[10][10][10]; hat als letztes Element cells[9][9][9];
| Zitat von _Ac_
Musst die Rückgabe ohne Stern machen, also
return cells[(x * Y + y) * Z + z];
die Variable cells hast du ja als Pointer definiert. Kannst du einfach normal wie eine andere Variable behandeln.
| |
Ne, dann kopiert er das Element an eine andere Adresse und gibt dieses zurück. Somit kann ich dann das Ursprungsarray cells nicht bearbeiten. Mit dem & Zeichen funktioniert es alles perfekt. Durch das ganze Zeigergetue komme ich mir grad sehr Ressourcenschonend vor.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von OliOli am 07.02.2011 13:19]
|
|
|
|
|
|
| Zitat von OliOli
| Zitat von Hyperdeath
Was soll eigentlich diese Index-Bestimmung?
Wenn du versuchst auf das Element 10,10,10 zuzugreifen, dann erhältst du mit (x * Y + y) * Z + z = 1110, hast jedoch nur 1000 Elemente.
Hyp
| |
Ne, denn Cell cells[10][10][10]; hat als letztes Element cells[9][9][9];
| Zitat von _Ac_
Musst die Rückgabe ohne Stern machen, also
return cells[(x * Y + y) * Z + z];
die Variable cells hast du ja als Pointer definiert. Kannst du einfach normal wie eine andere Variable behandeln.
| |
Ne, dann kopiert er das Element an eine andere Adresse und gibt dieses zurück. Somit kann ich dann das Ursprungsarray cells nicht bearbeiten. Mit dem & Zeichen funktioniert es alles perfekt. Durch das ganze Zeigergetue komme ich mir grad sehr Ressourcenschonend vor.
| |
ARGH! BESCHISSENES FORTRAN!
Ich bin total versaut, was das gute C angeht
Hyp
|
|
|
|
|
|
|
| Zitat von Tony.50
| Zitat von Gepan.3dsvs.com
Ist der Gradient = die Ableitung? Ich sehe die ganze Zeit im Numerik-Buch dieses "Dreieck" aka Gradient und es verhält sich irgendwie immer wie die Ableitung. Also ist Gradient = Ableitung?
| |
Gradient ist die Summe der partiellen Richtungsableitungen.
Will sagen: in nur einer Dimension ist der Gradient gleich der Ableitung.
| |
das ist die divergenz. gradient ist part. ableitungen als vektor
|
|
|
|
|
|
|
| Zitat von ChrissKL
x87: Was meinst du denn mit "niederwertigste Stelle? Klar ists mir leider nicht.
¤: Zwipos können auch toll sein
| Zitat von Achsel-des-Bösen
Ganz einfach: 6^1 hat hinten immer eine 6 (logisch ). Multiplizierst du es mit 6 hat du 36, was wiederum hinten einer 6 hat. 6 * 36 = 6*30 + 6*6. 6 * 30 hat hinten eine 0 und wenn du da die schon bekannten 6*6=36 drauf addierst, hat du an letzter Stelle 0+6 was wiederum 6 ist.
Das musst du jetzt nur noch irgendwie hübsch mathematisch schreiben
| |
Danke, aber da ich kein Mathematiker bin, wie drückt man das perfekt aus?
| |
Nach Induktionsannahme schreibst du
/e unnötig kompliziert gewesen..
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von Ballardbird_Lee am 07.02.2011 13:28]
|
|
|
|
|
|
| Zitat von NRG_Mash
| Zitat von Tony.50
| Zitat von Gepan.3dsvs.com
Ist der Gradient = die Ableitung? Ich sehe die ganze Zeit im Numerik-Buch dieses "Dreieck" aka Gradient und es verhält sich irgendwie immer wie die Ableitung. Also ist Gradient = Ableitung?
| |
Gradient ist die Summe der partiellen Richtungsableitungen.
Will sagen: in nur einer Dimension ist der Gradient gleich der Ableitung.
| |
das ist die divergenz. gradient ist part. ableitungen als vektor
| |
Äääh, stimmt natürlich.
|
|
|
|
|
|
|
| Zitat von NRG_Mash
| Zitat von Tony.50
| Zitat von Gepan.3dsvs.com
Ist der Gradient = die Ableitung? Ich sehe die ganze Zeit im Numerik-Buch dieses "Dreieck" aka Gradient und es verhält sich irgendwie immer wie die Ableitung. Also ist Gradient = Ableitung?
| |
Gradient ist die Summe der partiellen Richtungsableitungen.
Will sagen: in nur einer Dimension ist der Gradient gleich der Ableitung.
| |
das ist die divergenz. gradient ist part. ableitungen als vektor
| |
War da nicht was mit "der Gradient zeigt immer in die Richtung des dem höchsten Anstiegs"?
Nochmal an ChrissKL:
das nx^2 wird einfach weggelassen, da es ja positiv ist.
im Sinne von bla+nx^2 >= bla.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Ballardbird_Lee am 07.02.2011 13:39]
|
|
|
|
|
|
| Zitat von OliOli
| Zitat von _Ac_
Musst die Rückgabe ohne Stern machen, also
return cells[(x * Y + y) * Z + z];
die Variable cells hast du ja als Pointer definiert. Kannst du einfach normal wie eine andere Variable behandeln.
| |
Ne, dann kopiert er das Element an eine andere Adresse und gibt dieses zurück. Somit kann ich dann das Ursprungsarray cells nicht bearbeiten. Mit dem & Zeichen funktioniert es alles perfekt. Durch das ganze Zeigergetue komme ich mir grad sehr Ressourcenschonend vor.
| |
Nope.
int * a
int * b = a // Inhalt von a wird in b geschrieben. Inhalt = Adresse der Daten
int * a
int * b = &a // Adresse von a wird in b geschriben
|
|
|
|
|
|
|
Ich hatte es vorhin mal kurz so ausprobiert, bevor ich gepostet habe, und das Ergebnis hat meine Aussage bestätigt. Sonst würde ich gar nicht erst den Mund aufmachen.
Ist jetzt auch egal. Solange es läuft bin ich glücklich.
|
|
|
|
|
|
|
| Zitat von Wraith of Seth
Ins Blaue reingeraten:
Ich gehe mal von nein aus. Ich könnte mir ja z.B. eine Siedekurve in ein pV-Diagramm einzeichnen und eine zweite, die die irgendwo schneidet, aber eben nur da. Solange beides irgendeine Clausius-Clayperon-Gleichung löst, sollte es ja beides zulässig sein, oder nicht...?
...ich habe keine Ahnung, ob das richtig ist.
You all saw it! That orphanage attacked me!
| |
Also bei organischen Lösungenen/Lösungsmitteln kann man es wohl so machen (laut meines Profs).
Der Brechungsindex des Destillats war am Ende ganz okay.
Trotzdem danke
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Hessens_Psyko am 07.02.2011 14:03]
|
|
|
|
|
|
| Zitat von OliOli
Ist jetzt auch egal. Solange es läuft bin ich glücklich.
| |
Das nennt man dann Zeitbombe
Nochmals ausführlich, da ich mich au nicht ganz klar ausgedrückt habe bzw. ich nicht beachtet habe, dass du auf ein Element zugreifst:
|
Code: |
return cells[i] //gibt Element an Stelle i zurück (kopieren)
return &cells[i] // gibt Adresse von Element an Stelle i zurück
return *cells[i] //will einen Zeiger dereferenzieren, ist aber kein Zeiger
return cells // würde einen Zeiger auf das erste Element zurückgeben
return &cells // würde die Adresse des Zeigers auf das erste Element zurückgeben
return *cells //gibt das erste Element zurück
|
|
|
|
|
|
|
|
|
Ich steh gerade dummerweise auf dem Schlauch.
Was zur Hölle passiert da in dem markierten Schritt?
(Wahrscheinlich sollte ich nur mal ne Pause einlegen)
|
|
|
|
|
|
|
Ja, solltest du. Wie war das noch mit dem Erweitern von (oder hier: zu) Brüchen?
Where Wikipedia leads, I follow. BAAAAAH.
|
|
|
|
|
|
Thema: pOT-Informatiker, Mathematiker, Physiker V ( Haaahaaaaahaa...LabView...Hahahahaaa...oh wow ) |