Matroids Matheplanet Forum Index
Moderiert von Spock mire2
Mathematische Software & Apps » Mathematica » Wie schreibt man eine Funktion, die wiederum Funktionen schreibt?
Druckversion
Druckversion
Antworten
Antworten
Autor
Universität/Hochschule Wie schreibt man eine Funktion, die wiederum Funktionen schreibt?
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2013-09-23


Hallo.

Die Fibonaccizahlen kann man in mathematica folgenermaßen rekursiv implementieren:
mathematica
(* In *)
Clear @ fib
fib[n_Integer /; n >= 0] := 
 Block[{$RecursionLimit = \[Infinity], rec, m},
  rec @ 0 := 0;
  rec @ 1 := 1;
  rec [m_] := rec[m] = rec[m - 1] + rec[m - 2];
  rec[n]
  ]
 
fib[10]
fib[100]
(* Out *)
55
354224848179261915075

Analog funktioniert es z.B. für die Lucaszahlen und Tribonaccizahlen:
mathematica
(* In *)
Clear @ lucas
lucas[n_Integer /; n >= 0] := 
 Block[{$RecursionLimit = \[Infinity], rec, m},
  rec @ 0 := 2;
  rec @ 1 := 1;
  rec [m_] := rec[m] = rec[m - 1] + rec[m - 2];
  rec[n]
  ]
 
Clear @ tribo
tribo[n_Integer /; n >= 0] := 
 Block[{$RecursionLimit = \[Infinity], rec, m},
  rec @ 0 := 0;
  rec @ 1 := 1;
  rec @ 2 := 1;
  rec [m_] := rec[m] = rec[m - 1] + rec[m - 2] + rec[m - 3];
  rec[n]
  ]
 
lucas[10]
lucas[100]
tribo[10]
tribo[100]
 
(*Out*)
123
792070839848372253127
149
98079530178586034536500564
 

Bei allen 3 Funktionen handelt es sich um C-Rekurrenzen,also um homogene lineare Rekurrenzen mit konstanten Koeffizienten.

Diese kann man durch k Startwerte und die k Koeffizientenwerte kodieren.

Ich suche jetzt eine Funktion crecurrencegenerator,die mir unter anderem programmatisch obige Funktionen schreibt:

Also nach Eingabe von
mathematica
crecurrencegenerator[fib,{{1,1},{0,1}}]
crecurrencegenerator[lucas,{{1,1},{2,1}}]
crecurrencegenerator[tribo,{{1,1,1},{0,1,1}}]

soll mathematica die Funktionen fib,lucas und tribo kennen und man soll mit ihnen rechnen können.

Das Ganze soll für beliebige C-Rekurrenzen funktionieren.

Gruß endy





-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Buri
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2003
Mitteilungen: 46379
Wohnort: Dresden
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, eingetragen 2013-09-23


2013-09-23 19:21 - endy im Themenstart schreibt:
... soll mathematica die Funktionen fib,lucas und tribo kennen und man soll mit ihnen rechnen können.
Hi endy,
du würdest ja nicht fragen, wenn der vernünftige, halbwegs geradeaus zum Ziel führende Weg
Mathematica
  1. crecurrencegenerator[func_,coeff_,init_]
  2. :=Block[ ...
  3. (* und jetzt die Argumente coeff und init auseinanderpflücken *)
  4. (* und schließlich die "reine" Funktion, die das Ganze tut, *)
  5. (* irgendwie hinschreiben, mit *)
  6. func=Block[{...},... # ... &]
  7. ];
  8. Attributes[crecurrencegenerator]={HoldFirst};
nicht zum Ziel führen würde.
Möglicherweise habe ich mit dem "HoldFirst" den entscheidenden Tipp gegeben, denn sonst wird es wohl nicht klappen.
Auch sind reine Funktionen sicherlich eine unentbehrliche Zutat bei deinem Vorhaben.
Gruß Buri



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.2, vom Themenstarter, eingetragen 2013-09-24


Ich habe jetzt folgende lauffähige Version von crecurrencegenerator:
mathematica
Clear @ crecurrencegenerator
crecurrencegenerator[
  functionname_Symbol, {coefficientlist_List, 
    baselist_List} /; (Length @ coefficientlist == 
     Length @ baselist)] :=
 ( ClearAll @ functionname; 
  functionname @ n_ := 
   Block[{$RecursionLimit = Infinity, rec, m}, 
    Thread[Set[Evaluate[(rec /@ Range[0, Length @ baselist - 1])], 
      baselist]];
    rec[m_Integer /; m >= 0] := 
     rec @ m = 
      Evaluate[
       Sum[coefficientlist[[j]]*rec[m - j], {j, 1, 
         Length @coefficientlist}] ];
    rec @ n]
  )
 
crecurrencegenerator[fib, {{1, 1}, {0, 1}}]
crecurrencegenerator[lucas, {{1, 1}, {2, 1}}]
crecurrencegenerator[tribos, {{1, 1, 1}, {0, 1, 1}}]
Clear @ x
crecurrencegenerator[tschebyschow2, {{2 x, -1}, {1, 2 x}}]
 
fib @ 10
fib @ 100
lucas @ 10
lucas @ 100
tribos @ 10
tribos @ 100
tschebyschow2 @ 7 // Expand
 
 
 

Damit ergeben sich die Rekurrenzen und Ergebnisse aus dem Startbeitrag und die Tschebyschow-Polynome 2.ter Art.

Es scheint also zu funktionieren.

Allerdings sehen die Definitionen der Funktionen fib,lucas und tribo noch recht ungewöhnlich aus.

Gruß endy






-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Buri
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2003
Mitteilungen: 46379
Wohnort: Dresden
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.3, eingetragen 2013-09-24


2013-09-24 19:26 - endy in Beitrag No. 2 schreibt:
Ich habe jetzt folgende lauffähige Version ...
Hi endy,
na schön.
Also waren meine Hinweise völlig vergeblich.
Nun wüßte ich noch gern, was denn eigentlich @ für ein Operator ist.
Das kenne ich nämlich nicht.
Gruß Buri



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.4, vom Themenstarter, eingetragen 2013-09-24


@Buri:

Folgende 3 Möglichkeiten sind äquivalent:

Traditionalform,Postfixform und Praefixform
mathematica
Fibonacci[10]
10 // Fibonacci
Fibonacci @ 10

Gruß endy





-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Buri
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2003
Mitteilungen: 46379
Wohnort: Dresden
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.5, eingetragen 2013-09-25


2013-09-24 22:50 - endy in Beitrag No. 4 schreibt:
Folgende 3 Möglichkeiten sind äquivalent ...
Hi endy,
danke.
Gruß Buri



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.6, vom Themenstarter, eingetragen 2013-09-25


Die Funktion crecurrencegenerator aus Beitrag Nr.2 löst das Problem nicht.Sie erzeugt zwar anscheinend die richtigen Funktionen ,aber leider zum falschen Zeitpunkt.

Beispiel:

Wir berechnen die 10.te Tribonaccizahl 100000 mal ,indem wir die Funktion tribo schreiben und dann indem wir mit crecurrencegenerator die Funktion tribogenerated generieren.
mathematica
(* In *)
Clear @ tribo
tribo[n_Integer /; n >= 0] := 
 Block[{$RecursionLimit = \[Infinity], rec, m},
  rec @ 0 := 0;
  rec @ 1 := 1;
  rec @ 2 := 1;
  rec [m_] := rec[m] = rec[m - 1] + rec[m - 2] + rec[m - 3];
  rec[n]
  ]
 
Clear @ crecurrencegenerator
crecurrencegenerator[
  functionname_Symbol, {coefficientlist_List, 
    baselist_List} /; (Length @ coefficientlist == 
     Length @ baselist)] :=
 ( ClearAll @ functionname; 
  functionname @ n_ := 
   Block[{$RecursionLimit = Infinity, rec, m}, 
    Thread[Set[Evaluate[(rec /@ Range[0, Length @ baselist - 1])], 
      baselist]];
    rec[m_Integer /; m >= 0] := 
     rec @ m = 
      Evaluate[
       Sum[coefficientlist[[j]]*rec[m - j], {j, 1, 
         Length @coefficientlist}] ];
    rec @ n]
  )
 
 
n = 10^5;
Table[tribo @ 10, {j, Range[n]}]; // Timing // First
crecurrencegenerator[tribogenerated, {{1, 1, 1}, {0, 1, 1}}]
Table[tribogenerated @ 10, {j, Range[n]}]; // Timing // First
(* Out*)
6.255
12.231

Der Zeitunterschied lässt sich folgendermaßen erklären:
mathematica
? tribo
? tribogenerated

Das Problem ist also ,dass bei tribogenerated die Funktion bei jedem Aufruf zum Teil neu generiert wird,was natürlich Zeit kostet.

Also stellt sich die Frage:

Wie kann man die Funktion crecurrencegenerator so umschreiben,dass die Funktion tribogenerated wirklich nur einmal generiert wird.

Gruß endy








-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Buri
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2003
Mitteilungen: 46379
Wohnort: Dresden
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.7, eingetragen 2013-09-25


2013-09-25 20:44 - endy in Beitrag No. 6 schreibt:
... die Funktion bei jedem Aufruf zum Teil neu generiert wird,was natürlich Zeit kostet.
Hi endy,
das kann man doch irgendwie vermeiden.
Es ist bekannt, dass Set und SetDelayed unterschiedlich wirken.

Wenn man diese Wirkungsweise mit millionenfachen Aufrufen vergleicht, dann kommt selbstverständlich Murks heraus, wenn man es schlecht macht, also ohne gründliche Überlegung.

Ich begreife nicht, warum du die Funktion Evaluate mehrmals verwendest, geht das auch ohne diese Funktion?

Ich sehe in deinen Überlegungen überhaupt keinen Ansatz, die Funktion "zusammenzubasteln".
Aber prinzipiell muss das doch gehen, beim Ergebnis der Funktion crecurrencegenerator muss sich einfach um ein Objekt handeln, dass bei
Objekt // FullForm
einfach Function[ ... und hier steht, was die Funktion tut ...]
ergibt.

Anscheinend kommt bei deinem Ansatz irgendeine Regel heraus oder Tausende von Regeln, ich weiß es nicht.

Nach meinem Verständnis werden nämlich normale Funktionsdefinitionen durchaus in Regeln umgewandelt, oder sind diesen wenigstens ziemlich nahe, aber das weißt du natürlich.

Ich weiß es erst seit einigen Monaten, und du hast auch mit dazu beigetragen, mir zu dieser Erkenntnis zu verhelfen.
Gruß Buri



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
hieron
Senior Letzter Besuch: vor mehr als 3 Monaten
Dabei seit: 02.02.2013
Mitteilungen: 282
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.8, eingetragen 2013-09-26


hi endy

1) Wollte gerade die tribo-Funktion aus deinem ersten Kasten testen und stellte fest, dass mein Kernel bei tribo[10^5] oder höher abstürzt, bis tribo[10^4] geht's aber. Jetzt frage ich mich, ob das ein Mathematica7 spezifisches Problem ist.

2) Dann habe ich noch mit RSolve einen Programmierversuch für tribo unternommen. Sieht recht gut aus, zumal er die tribo[10^7] in knappen zwei Minuten berechnet. Der Haken dabei ist eine Abschätzung für die zu berechnenden Nachkommastellen. Das Testprogramm ist sehr kurz und so glaube ich, auch zu einem CRekurrenzGenerator ausbaufähig und geeignet.

Hier die Idee
Mathematica
sol = RSolve[{a[n + 3] == a[n + 2] + a[n + 1] + a[n], a[0] == 0, 
    a[1] == 1, a[2] == 1}, a[n], n];
tribonacci[n_] = a[n] /. First@sol;
 
(* eine Berechnung *)
ClearSystemCache[]; (* nach Timing-Tests rausschmeißen *)
Set[n, 10^5] // tribonacci // N[#, n*E/10] & // Rationalize // Timing // First

na dann viel Spaß beim Tüfteln  😄
gruß hieron



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.9, vom Themenstarter, eingetragen 2013-09-26


@ Buri:

Mit
mathematica
Clear @ tribo
tribo[n_Integer /; n >= 0] := 
 Block[{$RecursionLimit = \[Infinity], rec, m},
  rec @ 0 := 0;
  rec @ 1 := 1;
  rec @ 2 := 1;
  rec [m_] := rec[m] = rec[m - 1] + rec[m - 2] + rec[m - 3];
  rec[n]
  ]
 
Clear @ crecurrencegenerator
crecurrencegenerator[
  functionname_Symbol, {coefficientlist_List, 
    baselist_List} /; (Length @ coefficientlist == 
     Length @ baselist)] :=
 ( ClearAll @ functionname; 
  functionname @ n_ := 
   Block[{$RecursionLimit = Infinity, rec, m}, 
    Thread[Set[Evaluate[(rec /@ Range[0, Length @ baselist - 1])], 
      baselist]];
    rec[m_Integer /; m >= 0] := 
     rec @ m = 
      Evaluate[
       Sum[coefficientlist[[j]]*rec[m - j], {j, 1, 
         Length @coefficientlist}] ];
    rec @ n]
  )
 
 
crecurrencegenerator[tribogenerated, {{1, 1, 1}, {0, 1, 1}}]
? tribo
? tribogenerated
 
10 // tribo  // Trace 
10 // tribogenerated // Trace 
 

sieht man,dass durch crecurrencegenerator zwar nur eine Definition für tribogenerated produziert wird,aber diese ist gewissermaßen zu kompliziert,so dass man einen Rechenoverhead bekommt.

Auf Evaluate kann man nicht verzichten,da ansonsten wegen dem Block gar keine Rechnungen durchgeführt werden.

Evaluate wird 2mal benutzt um die Anfangswerte der Rekurrenz zu generieren und die eigentlich Rekurrenz.

@hieron:

Der Kernel stürzt bei mir bei deinen Werten für tribo auch ab.Dies liegt wohl daran,dass der Speicher vollgemüllt wird,da die Funktion tribo memorisiert ist.

RSolve nützt für das Problem nichts,da die expliziten Formeln im allgemeinen für C-Rekurenzen nicht existieren.Wenn man C-Rekurrenzen wirklich schnell berechnen will,sollte man es mittels Matrixpotenzen realisieren.Für die tribos kann man 107 mit Sicherheit deutlich schneller als in 2 Minuten berechnen,wenn man einen halbwegs neuen PC benutzt.

Gruß endy







-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
Buri
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2003
Mitteilungen: 46379
Wohnort: Dresden
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.10, eingetragen 2013-09-28


2013-09-26 19:42 - endy in Beitrag No. 9 schreibt:
... dass durch crecurrencegenerator zwar nur eine Definition für tribogenerated produziert wird,aber diese ist gewissermaßen zu kompliziert ...
Hi endy,
ich habe mir jetzt meine Lösung für das Problem überlegt.
Dabei habe ich festgestellt, dass meine Hinweise aus Beitrag #1 nicht funktionieren, denn
- man braucht das Attribut HoldFirst nicht, es geht auch so, und
- reine Funktionen sind alleine nicht ausreichend, weil die Funktionskörper zunächst unausgewertet bleiben, und man muss bei diesem Problem Mathematica irgendwie sagen, dass manche Sachen ausgewertet werden sollen und andere nicht, und das sogar innerhalb eines Terms.
Mathematica
  1. crecurrencegenerator[fu_,li_]:=Block[{t,i=0,j=0},
  2. Clear[fu];
  3. Scan[(fu[i++]=#)&,li[[2]]];
  4. fu[n_Integer/;n>=0]:=fu[n]=0;
  5. t=DownValues[fu];
  6. t[[++i,2,2]]=li[[1]];
  7. Scan[(t[[i,2,2,++j]]:=# fu[0+0];
  8. t[[i,2,2,j,2,1,1]]=t[[i,2,1,1]];
  9. t[[i,2,2,j,2,1,2]]=-j)&,li[[1]]
  10. ];
  11. t[[i,2,2,0]]=Plus;
  12. DownValues[fu]=t;fu
  13. ]
In diesem Programm sind mehrere Tricks versteckt, zum Beispiel die ausgewogene Benutzung von Set einerseits und SetDelayed andererseits.

In Zeile 11 würde man normalerweise die Funktion Apply benutzen, aber man kann nicht Plus @@ t[[i,2,2]] schreiben, denn das bewirkt
- das Auswerten von t[[i,2,2]], und
- das Ersetzen des Heads im Ergebnis durch Plus.
Ich möchte aber nur das Zweite tun, also muss ich Mathematica bitten, das zu tun, und glücklicherweise klappt das auch.
Es wäre selbstverständlich fehlerhaft, den Term von vornherein als Summe zu erzeugen, denn die Summanden würden dann als ungeordnet angesehen und in eine kanonische Reihenfolge gebracht, was bei nachträglichen Manipulationen an dieser Summe zu falschen Ergebnissen führen kann.

Meiner Ansicht nach gehört die Festlegung
$RecursionLimit=Infinity
nicht in die Funktionsdefinition, sondern man sollte diesen Wert setzen, bevor man die generierte Funktion benutzt.

Schließlich kann man auch andere Rechnungen durchführen, die ebenfalls Rekursion benutzen, und für die ein anderer Wert von $RecursionLimit sinnvoll ist.

Also zum Beispiel so:
Mathematica
  1. crecurrencegenerator[tribo,{{1,1,1},{0,1,1}}]
  2. Timing[$RecursionLimit=Infinity;tribo[100]]
  3. $RecursionLimit=20
  4. (* rechne irgendetwas anderes Rekursives *)
  5. tribo[$RecursionLimit=Infinity;1000]
Gruß Buri



Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.11, vom Themenstarter, eingetragen 2013-10-01


Hallo Buri,

deine Methode funktioniert hervorragend und ist wirklich clever.Vielen Dank dafür.

Ich habe mir jetzt noch eine andere Methode mittels Rules und dem Replacementoperator überlegt :
mathematica
Clear @ crecurrencegenerator
crecurrencegenerator[
  name_Symbol, {coefficientlist_List, 
    baselist_List} /; (Length @ coefficientlist == 
     Length @ baselist)] := Block[{rule},
   Clear  @ name;
  Table[name[j] := Evaluate[baselist[[j + 1]]], {j, 0, 
    Length @ baselist - 1}];
  name[rule] = 
   m_ :> Evaluate[
     Sum[coefficientlist[[j]]*name[m - j], {j, 1, 
       Length @coefficientlist}]] ;
  name[n_] := name[n] = n /. name[rule];
  ]
 
 

Gruß endy




-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy
Senior Letzter Besuch: im letzten Monat
Dabei seit: 10.01.2011
Mitteilungen: 3226
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.12, vom Themenstarter, eingetragen 2013-10-20


Hallo.

Man kann die Methode verallgemeinern und eine Funktion recurrencegenerator schreiben,die einem programmatisch beliebige lineare Rekurrenzen mit fester Ordnung als Funktion erzeugt.Die Koeffizienten brauchen also nicht konstant zu sein.
mathematica
Clear @ recurrencegenerator
recurrencegenerator[
  name_Symbol, {coefficientlist_List, baselist_List} /;  ( 
    Length @ coefficientlist == Length @ baselist), 
  variable_Symbol: True] :=
 Block[{length = Length @ baselist, var, varblank, n},
  Clear @ name;
  var = Table[
    ToExpression["var"~StringJoin~ToString @ j], {j, 1, length}];
  varblank = Map[Pattern[#, Blank[]] &, var];
  Table[name[{j}~Join~varblank] := Evaluate @ var[[j + 1]], {j, 0, 
    length - 1}];
  name[{n_Integer /; n >= 0}~Join~varblank] := 
   Evaluate @ 
    name[Join[{n - 1}, 
      var // RotateLeft // Most, {coefficientlist.var} /. 
       variable -> n]];
  ]
 

Die Erzeugung der Funktion name erfolgt mittels

recurrencegenerator[name,{coefficientlist,baselist},variable]

Hierbei ist variable der Laufindex der Rekurrenz und die coefficientlist hängt im allgemeinen von variable ab.Für C-Rekurrenzen bleibt alles wie gehabt und man kann variable einfach weglassen.

Die erzeugte Funktion ist iterativ.

Das n-te Element der Funktion kann man dann folgendermaßen berechnen:

name[{n}~Join~baselist]

Die Funktionen aus dem Startbeitrag,die Fakultät fac und die Derangementzahlen derange werden also auf folgende Art und Weise erzeugt und dann benutzt:
mathematica
recurrencegenerator[fibo, {{1, 1}, {0, 1}}]
Definition @ fibo
fibo[{10} ~Join~{0, 1}]
fibo[{100} ~Join~{0, 1}]
 
recurrencegenerator[lucas, {{1, 1}, {2, 1}}]
Definition @ lucas
lucas[{10} ~Join~{2, 1}]
lucas[{100} ~Join~{2, 1}]
 
recurrencegenerator[tribo, {{1, 1, 1}, {0, 1, 1}}]
Definition @ tribo
tribo[{10}~Join~{0, 1, 1}]
tribo[{100}~Join~{0, 1, 1}]
 
recurrencegenerator[fac, {{c}, {1}}, c]
Definition @ fac
fac[{10}~Join~{1}]
 
recurrencegenerator[derange, {{b - 1, b - 1}, {1, 0}}, b]
Definition @ derange
Map[derange[{#}~Join~{1, 0}] &, Range[0, 20]]
 


Gruß endy








-----------------
Dean Koontz : Zwielicht

Unzählige verschlungene Nachtpfade zweigen vom Zwielicht ab.
Etwas bewegt sich inmitten der Nacht,das nicht gut und nicht richtig ist.

The Book of Counted Sorrows.




Eine Notiz zu diese Forumbeitrag schreiben Notiz   Profil  Quote  Link auf diesen Beitrag Link
endy hat die Antworten auf ihre/seine Frage gesehen.
Neues Thema [Neues Thema] Antworten [Antworten]    Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2021 by Matroids Matheplanet
This web site was originally made with PHP-Nuke, a former web portal system written in PHP that seems no longer to be maintained nor supported. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]