Kalenderberechnungen ( Osterformel )

[enertegus]

Zitat von Tessi Das ich mit "and" eine Maske anwenden kann ist klar

Darum gings Dir doch, so dachte ich. Also es geht m.E. unproblematisch, da braucht es doch eine Feature?
Du kannst Dir ja eine Makrofunktion definieren...

Aber bevor man hier mathematische Ungetüme aufbaut, wäre ein simpler Shift-Befehl nicht nur einfacher in der Anwendung sondern auch unschlagbar schnell in der Ausführung.

Stimmt nicht wirklich. Integeroperationen werden wie shift-Operationen in einem Maschinenzyklus berechnet.
Also wäre
x=2*0x10
genau so schnell wie
x=shift(2,4)

[Tessi]

Zitat von enertegus Darum gings Dir doch, so dachte ich.

Nein, hier wird die Maske angewendet, aber so weit komme ich ja noch gar nicht, eben diese Maske kann ich nicht erzeugen

Zitat von enertegus Also es geht m.E. unproblematisch, da braucht es doch eine Feature?

Für die Anwendung der Maske natürlich nicht, aber für ihre Erzeugung schon!

Zitat von enertegus Du kannst Dir ja eine Makrofunktion definieren...

Mit welchen Mitteln? Es bleibt ja das Problem:
Ich habe nicht den passenden Multiplikator/Divisor sondern die Anzahl an Bits um die geschoben werden soll.

Also wie komme ich Deinem Beispiel von der Anzahl 4 auf den Multiplikator 0x10?
Und wie käme ich bei einem 63 Bit Shift (um z.B. aus 1u64 8000000000000000u64 zu machen) vom Wert 63 auf den notwendigen Multiplikator 8000000000000000u64?

Erst wenn das gelöst ist, dann kann ich multiplizieren oder Dividieren - und erst danach habe ich dann die Maske, die ich mit "and" dann einfach anwenden kann.

Zitat von enertegus Stimmt nicht wirklich. Integeroperationen werden wie shift-Operationen in einem Maschinenzyklus berechnet. Also wäre x=2*0x10 genau so schnell wie x=shift(2,4)

OK, nur muss ich für
x=2*0x10
die 0x10 erst einmal irgendwie aus der 4 bestimmen (und weiß noch nicht wie) und das kostet auch mindestens einen Maschinenzyklus. Aber selbst das und ein Makro wäre ja zunächst in Ordnung, wenn ich wenigstens eine Funktion hätte für die gilt:
f(00)=0x0000000000000001
f(01)=0x0000000000000002
f(02)=0x0000000000000004
f(03)=0x0000000000000008
f(04)=0x0000000000000010
f(05)=0x0000000000000020
f(06)=0x0000000000000040
f(07)=0x0000000000000080
f(08)=0x0000000000000100
...
f(60)=0x1000000000000000
f(61)=0x2000000000000000
f(62)=0x4000000000000000
f(63)=0x8000000000000000

So etwas aber fehlt und bevor eine solche Spezialfunktion implementiert wird, dann doch lieber gleich eine flexiblere Shift-Funktion.

Bislang könnte ich höchstens eine Schleife bauen, die 0x1 n mal mit 0x2 multipliziert, aber das benötigt nicht einige Maschinenzyklen sondern gleich bis zu 63 Verarbeitungszyklen zu je 20ms oder mehr (je nachdem was als Pause zwischen zwei Zyklen eingestellt ist). Und das ist keine wirkliche Alternative, das klingt wie ostfriesischer Lampenwechsel: Lampe festhalten, Haus drehen...
Ansonsten bliebe noch ein Array mit obigen 64 64 Bit Masken (in denen je genau 1 Bit gesetzt ist) und der Index korrespondiert mit der Bitposition. Geht sicherlich deutlich schneller, benötigt aber 512 vorberechnete Bytes in einem String. Momentan das Beste was mir einfällt, aber auch nicht wirklich der Weisheit letzter Schluss.
Mathematisch ginge es noch über die Potenzfunktion, aber ob pow(2,63) als f32 Wert berechnet nach der Konvertierung in einen u64 Wert tatsächlich auch genau 0x8000000000000000u64 ergeben wird, wage ich angesichts der recht schmalen Mantisse bei f32 und der näherungsweisen Berechnung (eben weil Fließkomma) der Potenz doch sehr zu bezweifeln - also eher keine Lösung...

Also alles nur Krücken, und das nur, weil ein einfaches Shift nicht existiert...

[Brick]

ich hoff ich bin nicht der einzige der das alles nicht mehr checkt ..

und was das mit Ostern zu tun hat versteh ich auch nicht mehr

nix für ungut

Martin

[Tessi]

Da bist Du wohl nicht allein, ich habe das Gefühl, auch jene, von denen ich erwartet/gehofft habe, das sie mir helfen können, haben Verständnissprobleme mit meinen Beiträgen. Sind sie vielleicht einfach zu lang???

Aber wenn es Dich noch interessiert, lies mal Beitrag #18 (und ggf. #16 als Einstieg), das könnte helfen, Licht ins Dunkle zu bringen. Ansonsten kannst Du hier mit dem Lesen aufhören...

Für diejenigen, die doch noch bei mir bleiben wollen:

In #18 möchte ich für einen Monat in einen u32 Wert für jeden Tag ein Bit haben, das signalisiert, ob das ein Feiertag ist, oder eben nicht, weil ich so in einem c1400 für rund 29 Jahre (29Jahre*12Monate*4Byte = 1392Byte) im voraus das ablegen kann und mir so jegliche Berechnungen, insbesondere die komplexe für Ostern, auf dem EibPC sparen kann und das statt dessen wesentlich komfortabler auf einem PC erledigen kann. Soweit gehörte das aus meiner Sicht noch zum Thema. Aber dann fiel mir was auf (und da wurde es dann OT aber um es verständlicher zu machen wiederhole ich es noch einmal in anderen Worten):

Den u32 Wert für einen bestimmten Monat eines bestimmten Jahres per Index aus dem c1400 zu holen ist einfach (Index = ((aktuelles Jahr - erstes Jahr) * 12 + Monat -1) * 4), aber ein bestimmtes Bit über dessen Positionsnummer aus dem u32 zu holen ist offenbar weitaus schwieriger als ich mir das gedacht habe.

Das es dafür keine spezielle Funktion geben würde und ich es über eine Maske isolieren muss war mir klar. Aber das es auch keine Funktion gibt um aus einem gegebenen Index (heute wäre das beispielsweise 10) eine Maske zu erzeugen bei der das entsprechende Bit gesetzt ist (heute also das 10. womit die Maske also 0x00000400u32 lauten müsste) das ist mir erst jetzt aufgefallen. Normalerweise erzeugt man so was über 0x1u32 shift left 10 und praktisch jede Programmiersprache kann das irgendwie. Nur wie ich das beim EibPC machen soll, hier gibt es einfach kein Shift, das hat mir immer noch keiner beantwortet, dabei dachte ich, es wäre trivial und #18 nicht nur der erste sondern auch der vorletzte Beitrag, der sich damit beschäftigt, statt dessen drehen sich jetzt schon 7 Beiträge darum und immer noch ist keine Lösung in Sicht. Dabei war es doch nur ein ganz kleiner Teilaspekt einer möglichen Lösung der Frage wie sage ich möglichst einfach dem EibPC wann ein Feiertag ist.

Tut mir leid, das das jetzt schon so lange OT ist, ich hatte nicht damit gerechnet, das die Isolation eines Bits über seine Positionsnummer aufwendiger zu werden droht, als die Berechnung von Ostern. Wobei ich ja immer noch auf eine Lösung hoffe, damit meine Lösung mit einem Bit-Array auch einfach implementierbar wird.

[enertegus]

Zitat von Tessi Aber selbst das und ein Makro wäre ja zunächst in Ordnung, wenn ich wenigstens eine Funktion hätte für die gilt: f(00)=0x0000000000000001

Du kannst Dir doch ein eigenes Funktions Makro bauen, dass das liefert. Aufgrund des Validierungskonzepts würde das für
s=u*f(2)
auch nur f(2) ein einziges mal bestimmen. Oder ich hab Dich nicht verstanden (?). Oder nochbesser: Mach Dir das Shift-Makro gleich selbst. Ginge doch auch. Du weisst schon, dass man inzwischen Makros programmieren kann, die sich wie eine Funktion anwenden lassen?

[Bodo]

Zitat von enertegus Du weisst schon, dass man inzwischen Makros programmieren kann, die sich wie eine Funktion anwenden lassen?

Hoi

Ganz kurz, wo ist das beschrieben?

[enertegus]

Zitat von Bodo Hoi Ganz kurz, wo ist das beschrieben?

S. 246 (Handbuch EibStudio 2.311) - das Beispiel ist das cosh-Makro das wie eine eingebaute Funktion genutzt wird.

[Bodo]

Hoi Michael

Danke.

[Tessi]

Die Funktions-Makros finde ich großartig und ich würde sofort eines schreiben...

Aber wie kann ich die Funktion f(n) ohne eine Shift-Funktion sauber implementieren?
Alternativ könnte 2^n berechnet werden aber auch das geht nicht als u32 oder gar u64.

Also was sollte ich in das Makro hineinschreiben??

Das ist mein Problem!

[enertegus]

Zitat von Tessi Die Funktions-Makros finde ich großartig und ich würde sofort eines schreiben... Das ist mein Problem!

Was spricht gegen:

s=Wert*convert(pow(2f32,convert(Shifter),0f32),0u64) 

und dann halt schick verpacken z.b. in ein Makro
ShiftLinks(Wert,Shifter)
usw..