|
|
|
|
|
|
|
Kurze Zwischenfrage, da ich mich mehr verwirre, je länger ich drüber nachdenke.
 und  das Kronecker-Symbol.
Ich war mir sehr sicher, dass für Vektoren y^k folgendes gilt :
Aber je länger ich auf das mehr oder weniger gleiche gucke:
...übernehme ich meine Rechnung, komme ich auf
...aber irgendwie verunsichert mich das gerade massiv...
Zweite Meinungen? Sprich: Habe ich mein Index-Jutsu noch richtig in Erinnerung?
¤ðiŧ:
Mathematica übertreibt es, aber die Frechet-Ableitung sieht so aus wie ich es wollte. Nur brauche ich noch keine Dirac-Deltas, Kroneckers reichen mir. Ist aber eh mir oder weniger das selbe...
|
|
[Dieser Beitrag wurde 5 mal editiert; zum letzten Mal von Wraith of Seth am 22.03.2014 4:21]
|
|
|
|
|
|
|
|
|
|
|
|
|
Python 101 mit WoS
|
| |
| Code: |
def gerade(Y0,YK):
strecke = []
for i in range(0,nint):
f(t) = YO[i] + t*(YK[i]-Y0[i])
strecke.append(f)
return strecke |
|
Das gibt den lustigen Fehler beim Aufruf der Funktion, dass die globale Variable Y0 nicht definiert sei. WTF? Das ist doch eine lokale Variable, die ich - wie schon dutzende Male zuvor - doch einfach in der Definition eingeführt habe. Wieso stört ihn das hier plötzlich?
Das einzig globale, auf das ich zugreife, ist nint - aber ihn stört stattdessen Y0...
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Wraith of Seth am 22.03.2014 9:34]
|
|
|
|
|
|
|
|
|
|
großes o != Null
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Redh3ad am 22.03.2014 9:43]
|
|
|
|
|
|
|
|
|
...das hätte ich im Leben nicht gesehen. Warum müssen die Tasten auch so nahe beeinander sein? 
|
|
|
|
|
|
|
|
|
|
Und warum drückst du dazu auch noch Shift?
Evtl. solltest du einfach einen anderen Font nutzen, bei dem man O und 0 einfach unterscheiden kann.
|
|
|
|
|
|
|
|
|
Sage 101 WoS
|
Hm. Ich hoffe, diesmal was interessanteres zu haben:
| |
| Code: |
nint = 250 #Anzahl der Interpolationspunkte
kreis(t) = (cos(2*pi*t),sin(2*pi*t));
kreissin(t) = ((1-0.25*sin(10*2*pi*t))*cos(2*pi*t), (1-0.25*sin(10*2*pi*t))*sin(2*pi*t));
p1 = [kreissin(i/nint) for i in range(0,nint)]
p2 = [kreis(i/nint) for i in range(0,nint)]
def gerade(Y0,YK):
var('t')
strecke = []
for i in range(0,nint):
strecke.append(Y0[i] + t*(YK[i]-Y0[i]))
return strecke
test = gerade(p1,p2) |
|
Was es sein soll: Eine Liste von Abbildungen t |--> R^2. Das ist es auch meistens. Nur wenn test[0] ist ein gutes Beispiel dafür, dass ich eine Konstante und keine konstante Funktion bekomme. Klingt harmlos, ist aber schlimm, weil ich Fehler bekomme, sobald ich versuche, jedes Element zu plotten oder an einem Punkt auszuwerten.
Wie bekomme ich das hin? Hier wird auf mehr oder weniger das gleiche Problem eingegangen, aber die Lösungen dort bekomme ich nicht so auf meine Liste übertragen. Z.B. funktioniert nicht
| |
| Code: |
for i in range(0,nint):
strecke[i](t) = Y0[i] + t*(YK[i]-Y0[i])
_______
SyntaxError: can't assign to function call
|
|
Dabei sehen die Vorschläge aus der Seite so aus:
| |
| Code: |
sage: f(x) = x # instead of 'f = x'
sage: g = f.derivative()
sage: g
x |--> 1 |
|
| |
| Code: |
sage: f = x
sage: g(x) = f.derivative() # instead of 'g = f.derivative()'
sage: g
x |--> 1 |
|
Ideen? 
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Wraith of Seth
| |
| Code: |
for i in range(0,nint):
strecke[i](t) = Y0[i] + t*(YK[i]-Y0[i])
_______
SyntaxError: can't assign to function call
|
|
| |
Das ist dann irgendein Konstrukt von Sage, von dem ich keine Ahnung habe. In pure Python würde man das mit lambda-Ausdrücken machen.
| |
| Code: |
for i in range(0,nint):
strecke[i] = lambda t: Y0[i] + t*(YK[i]-Y0[i]) |
|
Wobei sich mir auch nicht erschließt, warum du nicht einfach eine Funktion mit zwei Argumenten (i und t) nimmst, statt später aufzurufen
|
|
[Dieser Beitrag wurde 3 mal editiert; zum letzten Mal von Redh3ad am 22.03.2014 11:10]
|
|
|
|
|
|
|
|
|
__________________________
¤DIT:
Ich habe jetzt was, was zwar unelegant ist, aber funktioniert. Die Frucht meiner Arbeit wird gleich hier zu sehen sein.
| |
| Code: |
def gerade(Y0,YK,i,t):
var('t')
return Y0[i] + t*(YK[i]-Y0[i]) |
|
Ich hatte gehofft, die "mathematischen Objekte", die ich da eigentlich rumwedel, geschlossener erhalten zu können.
Naja, unelegant, aber funktioniert schon. Und jetzt hat diese Gerade so lange gedauert, wie ich dachte, dass das gesamte Vorgeplänkel dauern würde.
Was freue ich mich auf den Moment, wo die eigentlichen KErnstücke geschrieben werden. Das werden seeeeehr lange Formeln, die eingehackt werden wollen, bevor ich auch nur die Chance habe, zu sehen, ob das, was ich da getippt habe, richtig ist...
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von Wraith of Seth am 22.03.2014 11:55]
|
|
|
|
|
|
|
|
|
Ich suche einen eleganten Algorithmus (in Matlab), der folgendes Problem löst: Ich habe eine Folge von Wahr/Falsch-Werten und möchte die Position der längsten Folge von Wahr-Werten, wobei einzelne Falsch-Werte ignoriert werden sollen. Einmal aufgezeichnet:
| |
| Code: |
Position: 1 5 10 15 20 25
Werte: 0 0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 1 1 1 0 0 0 0 0 1 1 0
|-------| |-----------------| |---|
Folgen: Länge 4 Länge 9 Länge 2
Rückgabe: 11 - 19 |
|
Hat jemand eine elegante Idee, wie man das lösen kann? Aktuell verwende ich diesen Code:
| |
| Code: |
% Lücken stopfen
for i=2:size(interesting)-1
interesting(i) = interesting(i) || (interesting(i-1) && interesting(i+1));
end
% Längste Folge suchen
x = cumsum(interesting~=1);
interesting = find(x==mode(x)); |
|
Aber so richtig schön kommt mir das noch nicht vor. Hat jemand von euch eine Idee?
/edit: erstmal funktionierenden Code posten 
|
|
[Dieser Beitrag wurde 5 mal editiert; zum letzten Mal von Danzelot am 22.03.2014 16:21]
|
|
|
|
|
|
|
|
|
/e: Ach, die Position! mom.
/e: Achso, es geht um Matlab beautiness. Dann keine Ahnung, grad nicht installiert.
/e: Gute Gelegenheit, es mal wieder zu installieren.
|
|
[Dieser Beitrag wurde 3 mal editiert; zum letzten Mal von Oli am 22.03.2014 17:04]
|
|
|
|
|
|
|
|
|
|
Das Problem ist hier weniger der Algorithmus, als ihn in Matlab auszudrücken, oder?
|
|
|
|
|
|
|
|
|
|
|
|
Ja
|
|
|
|
|
|
|
|
|
|
|
Hier du son of life.
| |
| Code: |
interesting = [0 0 1 0 1 1 0 0 0 0 1 1 1 0 1 0 1 1 1 0 0 0 0 0 1 1 0];
new = bitor(conv2(interesting, [1 1 1], 'same') > 1, interesting);
is = find(diff([0 new]) == 1);
ie = find(diff([new 0]) == -1);
[c,i] = max(ie - is + 1);
is(i)
ie(i) |
|
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Oli am 22.03.2014 17:22]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
conv2 legt einen FIlter [1 1 1] über das Array, wodurch jeder EIntrag zur Summe mit seinen Nachbarn wird. Eine 0 umgeben von 1en wird also eine 2. Das Ergebnis davon > 2 ist also ein array, wo alle einzelnen Nullen Einsen sind. bitor ist ein einfaches &, also bitor(.., interesting) ergibt das ursprüngliche Array mit Lücken gefüllt.
find(diff( findet sozusagen Stufen, also da, wo 0 zu 1 wird und andersrum. Das sind die Anfangs- und Endpunkte der Sequenzen. Dann mit max() noch schnell die längste finden und fertig.
Zur Hälfte ergoogelt.
/e: Der Aufwand ist vermutlich 5N oder noch schlimmer, aber er wollte ja eine elegante (*ähem*) Lösung und keine effiziente.
/e: Wenn ich so drüber nachdenke.. Diesen Filter könnte man auch verwenden, um die Anfänge und Enden der Sequenzen zu entdecken. Wenn man immer ar(i)-ar(i+1) macht, dann bedeutet eine -1, dass von 0 auf 1 gewechselt wird und eine +1 von 1 auf 0. Aber damit rumzufummeln überlasse ich dir.
/e: Vielleicht geht's ja sogar mit nur einem Filter? Das wäre natürlich am coolsten.
|
|
[Dieser Beitrag wurde 3 mal editiert; zum letzten Mal von Oli am 22.03.2014 17:34]
|
|
|
|
|
|
|
|
Ja, das ist echt hübsch  Und conv2 hat mir bei meinen ersten Versuchen gefehlt, ich habe mich mit filter herumgenervt
|
|
|
|
|
|
|
|
|
|
| | Zitat von Oli
Der Aufwand ist vermutlich 5N oder noch schlimmer
| |
5n ist n und damit das beste, was du hier erreichen kannst.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Rufus am 22.03.2014 17:45]
|
|
|
|
|
|
|
|
|
|
Pah, meine Methode oben war auch schon in O(n). Das muss besser gehen!
|
|
|
|
|
|
|
|
|
|
|
|
Länge von Sequenzen in O(1) bestimmen klingt nach einem Turing-Award...
|
|
|
|
|
|
|
|
|
|
|
|
Ich überlege die ganze Zeit, ob nlogn möglich wäre, aber ich bezweifle es irgendwie.
|
|
|
|
|
|
|
|
|
|
|
|
Ne glaube ich nicht. Es gibt ja sicher überraschend schnelle Algorithmen für vieles, aber hier bin ich mir doch ziemlich sicher, dass das nicht geht.
|
|
|
|
|
|
|
|
|
|
|
Hätte man das Ausgangsarray intelligenter, als Baum oder so, aufgebaut, ginge es vermutlich.
An dieser Stelle sei ein gepflegter rant eingebracht.
Matlab ist kacke. Und zwar, weil sowas wie oben möglich ist. KEINE SAU VERSTEHT WAS DER CODE MACHT! Das ist write-only code. Das suckt! Danzelots ursprüngliche Lösung war viel besser! Und in Matlab ist es schier unmöglich, Code von anderen Menschen zu lesen.
Python tendiert da auch hin. Dieses Einzeiler-voodoo ist im Moment des Programmierens toll, aber sonst auch für nichts nütze.
Außerdem: 5N ist immer schlechter als N. Als Informatiker mag das äquivalent sein, aber ein Anwender freut sich auch über einen konstanten Faktor in der Geschwindigkeit. Wenn meine Simulationen anstatt in einer Woche an einem Tag durchlaufen würden, schwebte ich auf Wolke 7.
|
|
|
|
|
|
|
|
|
|
|
Es wurde hier bestimmt schon mal angesprochen, ich habe dazu aber nichts gefunden. Seit einigen Wochen kursieren lustige Videos durch YouTube, die beweisen wollen, die Summe aller natürlichen Zahlen sei = -1/12.
Nun sind da einerseits seriöse Physiker dabei, die auch behaupten, dass dieses Ergebnis in mehreren Bereichen der Physik vorkommt (String Theorie). Andererseits wird bei dem Beweis mit divergierenden Reihen gespielt, z. B. wird die Reihe 1-1+1-1+1... mit 1/2 gleichgesetzt.
Kann mir vielleicht jemand erklären, wo der Haken ist, und wieso das in der Physik gebraucht wird?
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Olschi
Es wurde hier bestimmt schon mal angesprochen, ich habe dazu aber nichts gefunden. Seit einigen Wochen kursieren lustige Videos durch YouTube, die beweisen wollen, die Summe aller natürlichen Zahlen sei = -1/12.
Nun sind da einerseits seriöse Physiker dabei, die auch behaupten, dass dieses Ergebnis in mehreren Bereichen der Physik vorkommt (String Theorie). Andererseits wird bei dem Beweis mit divergierenden Reihen gespielt, z. B. wird die Reihe 1-1+1-1+1... mit 1/2 gleichgesetzt.
Kann mir vielleicht jemand erklären, wo der Haken ist, und wieso das in der Physik gebraucht wird?
| |
Dieser "anschauliche" Beweis in dem Video hält natürlich keiner Mathematik stand 
Denn bei unendlich vielen Summanden kommt es darauf an wie man die Summanden gruppiert.
1-1+1-1+1-1 .., = 1/2 (angbelich )
(1-1) + (1-1) + (1-1)+ ... = 0 + 0 +0 +0 = 0
Das sollte das Problem schon veranschaulichen mit der herangehensweise im Video.
Ich hatte irgendwo mal ne vernünftige Herleitung dafür, aber im Prinzip benutzen wir das um Divergenzen zu regularisieren. D.h. man muss sich immer klaren sein, was diese -1/12 da eigentlich sind.
Man kann der Summe diesen Wert zuweisen, da man mit in der komplexen Ebene ne haufen Voodoo betreiben kann um die Summe aus der zeta-funktion heraus zu rechnen.
Wenn ich mich richtig erinnere, ist der Trick sich das nur aus ner anderen sichtweise anzugucken, so dass die Divergenz vom endlichen Teil der summe getrennt werden kann. D.h
 .
Den divergenten Teil 1/eps schmeißt man dann einfach weg (bzw. er muss sich später in der Rechnung einfach rauskürzen, sodass wir den endlichen Teil behalten können)
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von SilentAssassin am 22.03.2014 18:42]
|
|
|
|
|
|
|
|
|
| | Zitat von Olschi
Es wurde hier bestimmt schon mal angesprochen, ich habe dazu aber nichts gefunden. Seit einigen Wochen kursieren lustige Videos durch YouTube, die beweisen wollen, die Summe aller natürlichen Zahlen sei = -1/12.
Nun sind da einerseits seriöse Physiker dabei, die auch behaupten, dass dieses Ergebnis in mehreren Bereichen der Physik vorkommt (String Theorie). Andererseits wird bei dem Beweis mit divergierenden Reihen gespielt, z. B. wird die Reihe 1-1+1-1+1... mit 1/2 gleichgesetzt.
Kann mir vielleicht jemand erklären, wo der Haken ist, und wieso das in der Physik gebraucht wird?
| |
Iirc hilft es beim "Regularisieren", also dabei, unerwünschte Dinge aus der REchnung zu kegeln. Alles andere als einfach oder anschaulich. Die "Beweise", die so gerne auf Youtube gezeigt werden, sind aber prinzipiell alle FALSCH, weil sie Dinge mit unendlichen, divergenten Reihen tun, die man damit nicht machen darf, ohne dass man sich in Widersprüche verstrickt.
Mehr dazu:
http://terrytao.wordpress.com/2010/04/10/the-euler-maclaurin-formula-bernoulli-numbers-the-zeta-function-and-real-variable-analytic-continuation/
|
|
|
|
|
|
|
|
|
|
|
Danke.
Vielleicht kann ich dann wieder in Ruhe penen.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Olschi am 22.03.2014 19:22]
|
|
|
|
|
|
|
|
|
| | Zitat von Olschi
Andererseits wird bei dem Beweis mit divergierenden Reihen gespielt, z. B. wird die Reihe 1-1+1-1+1... mit 1/2 gleichgesetzt.
Kann mir vielleicht jemand erklären, wo der Haken ist
| |
Ramanujan summation ist der "Haken". Es ist halt nicht der echte Wert der Reihe, weil divergierende Reihen ja keinen haben (auch nicht, wenn ein Füsiker sich hinsetzt und 1+1-1+1-1+1-1 = 1/2 schreibt).
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von csde_rats am 22.03.2014 19:22]
|
|
|
|
|
|
|
|
|
| | Zitat von Oli
Außerdem: 5N ist immer schlechter als N. Als Informatiker mag das äquivalent sein, aber ...
| |
Komplexitätsbegriff der Informatiker außer Acht lassen? Ganz wie du willst: Dann soll dein Anwender halt schnellere Hardware kaufen.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Rufus am 22.03.2014 19:29]
|
|
|
|
|
|
|
|
|
| | Zitat von Olschi
Danke.
Vielleicht kann ich dann wieder in Ruhe penen.
| |
Jeder mag penen!
|
|
|
|
|
|
|
|
| Thema: pOT-lnformatik, Mathematik, Physik XVI ( Ship painting activities ) |
