Suchwörter   (werden UND-verknüpft)
Keines der folgenden   keine eigenen Beiträge
Name des Autors 
resp. Themenstellers 

nur dessen Startbeiträge
auch in Antworten dazu
Forum 
 Suchrichtung  Auf  Ab Suchmethode  Sendezeit Empfehlungbeta [?]
       Die Suche erfolgt nach den angegebenen Worten oder Wortteilen.   [Suchtipps]

Link auf dieses Suchergebnis hier

Forum
Thema Eingetragen
Autor

Relativitätstheorie
Universität/Hochschule 
Thema eröffnet von: hyperG
Eindeutige Definition vom Epsilon-Tensor  
Beitrag No.6 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-12 19:35
hyperG
 

2021-04-12 18:45 - Kezer in Beitrag No. 5 schreibt:
... ans Herz legen, die Definition einer (mathematischen) Funktion zu wiederholen/studieren.

Genau darum geht es ja gerade, dass jeder Professor denkt, dass seine Definition eindeutig sei! Für "seine Gedankenwelt" mag es auch stimmen, ABER sobald man auch nur etwas abweicht, werden Zeichen & Symbole anders verwendet! Schon innerhalb der Mathematik (Statistik anders als Mengen-Logik usw.)

Ich könnte Dir zig Beispiele nennen, dass sie - über ALLE Wissenschaftsgebiete - nicht eindeutig sind!

 | mal "Teiler von", mal  "Menge oder Klasse der Elemente ..., die die Bedingung ... erfüllen
x mal Produkt-Symbol, mal kartesisches Produkt, ...
\ mal Differenz der Mengen ... und ...; mal floor(.../...)
|...| mal Absolutbetrag; mal Mächtigkeit, mal Determinante ,...
...

Schau Dir nur mal de.wikipedia.org/wiki/Liste_mathematischer_Symbole an! Voller Mehrdeutigkeiten und fehlender Randbedingungen!

Sobald man "echt wissenschaftlich" arbeitet und mehrere Wissenschaftsgebiete ohne starres Schubfachdenken verbindet, darf es keine Missverständnisse oder Inkompatibilitäten geben!

Dann die oft "in der Luft hängenden Variablen". Für Mathematiker in ihrer Gedankenwelt reicht das (wird oft als "für alle").

Eine Möglichkeit für mehr Eindeutigkeit für ein Algorithmus ist oft der Pseudocode.
Er könnte in diesem Fall etwa so aussehen (wenn ich alles richtig verstanden habe):
Pseudocode
geg.: aA =Array{...} mit n Gliedern
n=Len(aA)
prod=1
if (aA[n]>n)or(aA[n]<1) return Err
for k=1 to n-1
 if (aA[k]>n)or(aA[k]<1) return Err
 for j=k+1 to n
   if aA[j]==aA[k] return 0;
   prod*=(aA[j]-aA[l])/(j-k)
 next j
next k
return prod

 

Relativitätstheorie
Universität/Hochschule 
Thema eröffnet von: hyperG
Eindeutige Definition vom Epsilon-Tensor  
Beitrag No.4 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-12 18:32
hyperG
 

2021-04-12 17:59 - Kezer in Beitrag No. 3 schreibt:
...
Sowas wie "fehlende Zahl" gibt es nicht.

Doch, in der exakten Definitionswelt gibt eine sauber definierte Funktion für undefinierten "Zweig" Error {sauber definierter Abbruch} zurück.
(Um Abstürze oder Endlosschleifen zu vermeiden)

OK, danke das mit p & q habe ich nun verstanden.
Probe
 f(3,4,1,2) -> 2 Vertauschungen -> ((2+1) mod 2)*2-1 = 1
(4-3)/(2-1)*(1-3)/(3-1)*(2-3)/(4-1)*(1-4)/(3-2)*(2-4)/(4-2)*(2-1)/(4-3)=1
-> stimmt überein.

Für beide verbal formulierten Teile
- "1-Schritt-Vertauschungen 2er Glieder bis Muster ... erreicht"
- "für alle p,q mit der Eigenschaft ... wende Funktion ... an"
gibt's bestimmt auch bessere Funktionen...

Relativitätstheorie
Universität/Hochschule 
Thema eröffnet von: hyperG
Eindeutige Definition vom Epsilon-Tensor  
Beitrag No.2 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-12 17:49
hyperG
 

\(\endgroup\)
\(\begingroup\)\(\newcommand{\Q}{\mathbb{Q}} \newcommand{\R}{\mathbb{R}} \newcommand{\Z}{\mathbb{Z}} \newcommand{\OO}{\mathcal{O}} \newcommand{\Spec}{\operatorname{Spec}} \newcommand{\Gal}{\operatorname{Gal}}\)2021-04-12 17:11 - Kezer in Beitrag No. 1 schreibt:
... wenn $i,j,k \in \{1,2,3 \}$ ist?
...
\(\endgroup\)
Das habe ich selbst im Wiki-Beitrag NICHT gefunden.

Soll das bedeuten:
f(9,8,7)=Error? {da nicht definiert}


Außerdem bedeutet eine Aufzählung {Spektrum-Version} in einem Case-Verteiler mit Komma normalerweise "UND"
Die engl. Wiki-Version spricht aber von ODER!

Allein das zeigt, wie schwammig das alles ist & dass sich allein schon diese beiden Artikel widersprechen!

Ich habe selbst studiert & immer wenn was Schwammig war, habe ich nachgefragt. (Professoren kürzen gern ab)

Das p & q steht weiterhin offen zur Frage.

Wenn das alles so einfach ist, wie sieht's mit fehlender Zahl aus?

Also f(3,2,1,5) -> auch Error?

Dann die Definition von "Vertauschung": immer 2 Glieder?
Also f(3,4,1,2)
3412 {1 & 3}
1432 {4 & 2}
1234
also 2 Vertauschungen und ((2+1) mod 2)*2-1 = 1



Relativitätstheorie
Universität/Hochschule 
Thema eröffnet von: hyperG
Eindeutige Definition vom Epsilon-Tensor  
Themenstart
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-12 17:02
hyperG
 

Unter Spektrum Warum kompliziert manchmal einfacher ist
findet man die schwammige Definition


Weiter unten wird dann ein Beispiel genannt:
"Anzahl der nötigen Vertauschungen, um das Zahlenmuster {1,2,3} zu bekommen" -> also habe ich das so verstanden:
fed-Code einblenden

Aber was ist mit
fed-Code einblenden
? Denn selbst mit unendlich vielen Vertauschungen bekomme ich damit kein "Muster" {1,2,3} hin...

Unter Wiki fand ich dann
de.wikipedia.org/wiki/Levi-Civita-Symbol
wo aber was von i,j,k,...
also beliebig vielen Parametern steht!

In der engl. Version unter
en.wikipedia.org/wiki/Levi-Civita_symbol
steht dann wieder was von i==k OR j==k
ABER auch nicht von dem Fall: eine Variable hat einen Wert größer 3

wikimedia.org/api/rest_v1/media/math/render/svg/2fb4e75f40e663922749de1a071fb29728ff2f8c

... mit undefinierten Parametern p & q.

Wird da absichtlich was verschleiert, oder ist bis heute keiner in der Lage eindeutige Funktionsdefinition zu erstellen?

Grüße


Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.20 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-10 21:59
hyperG
 

Habe Matrix nochmals vergrößert und innerhalb der DLL eine weitere Zeitmessung eingebaut, um die einzelnen Teile genauer zu wichten:
Mathematica
...
Mathematica mit Zeilen=1600 in 4.8113637 s (20 Threads)
##########################################################
ToString-Zeit= 2.0932562 s für Stringlänge=50724392
Out[60]= 130447345940674970221040119937474534622|134141310587451575514436998016498418451|132434804116790553911875000497573729388|132444398777051631491804143650344953404|148230478352533030088373115458006404763
Gesamt= 24.2130332 s; interne DLL-Schleifen: 23.65 s (1 Thread)
 
24.213-23.65=0.563 s für Übertragung + Wandlung + Speicheranforderung + Rückwandlung + Speicherfreigabe + Wertrückgabe
 

Solch 39stelligen Zahlen sind schon gewaltig.

Bei den bereits optimierten Dot-Befehlen lohnt es sich natürlich nicht.

Notationen, Zeichen, Begriffe
Beruf 
Thema eröffnet von: FrankHeyne
Formel erstellen  
Beitrag No.10 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-10 00:30
hyperG
 

Da finde ich ggT aber einfacher & verständlicher, als diese
"versteckte Schleife" -> z.B. While-Schleife:
mathematica
f[n_]:=Module[{k =n+1},While[Mod[n,2^k]!=0,k--]; k] ;
Table[{i,i/2^f[i],i/2^IntegerExponent[i, 2],i/GCD[i,2^i] },{i,20}]//Grid
1	1	1	1
2	1	1	1
3	3	3	3
4	1	1	1
5	5	5	5
6	3	3	3
7	7	7	7
8	1	1	1
9	9	9	9
10	5	5	5
11	11	11	11
12	3	3	3
13	13	13	13
14	7	7	7
15	15	15	15
16	1	1	1
17	17	17	17
18	9	9	9
19	19	19	19
20	5	5	5

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.18 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-09 21:24
hyperG
 

Dann doch gleich "nur ToString", was bei mir 1.15 s dauert.
Den Replace-Teil, der bei Mathematica 0.9 s dauert,
lasse ich dann in der DLL in 0.03 s erledigen.

Die Stringlänge vergrößert sich auf 28533074 Zeichen.

Grüße Gerd

P.S.: Die vergrößerte Stringlänge ist schon in den 0.03 s mit enthalten.
Effektiv verbessert sich also mit "nur ToString" die Wandlungsgeschwindigkeit um den Faktor 4 s/(1.15 +0.03 s)=3.39 !
Super, dass wir zusammen auch hier bei der 28 Mio. Bytes Übertagung noch was herausholen konnten.

Notationen, Zeichen, Begriffe
Beruf 
Thema eröffnet von: FrankHeyne
Formel erstellen  
Beitrag No.7 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-09 19:59
hyperG
 

2021-04-08 11:22 - FrankHeyne im Themenstart schreibt:
... Funtion mathematisch korrekt als Einzeiler ausdrücken?
...
Vielen Dank schon mal sagt
Frank

Hallo Frank,

Was die meisten vergessen haben, ist der Zusatz: 0 für n<=0
(für Programmierung & gegen Endlosschleifen wichtig)
aber den lasse ich mal weg.

Hier 2 Einzeiler ohne "Case" oder anderen Fallunterscheidungen:

fed-Code einblenden

oder

fed-Code einblenden

Hier die Wertetabelle, die die Gleichheit zeigt:
mathematica
f[n_]:=Which[n<=0,0,Mod[n,2]==0,f[n/2],Mod[n,2]>0,n];
f2[n_]:=Which[n<=0,0,n>0,Mod[n+1,2]*f2[Ceiling[n/2]]+Mod[n,2]*n];
Table[{n,f[n],f2[n],n/GCD[n,2^n]},{n,1,32}]//Grid
1	1	1	1
2	1	1	1
3	3	3	3
4	1	1	1
5	5	5	5
6	3	3	3
7	7	7	7
8	1	1	1
9	9	9	9
10	5	5	5
11	11	11	11
12	3	3	3
13	13	13	13
14	7	7	7
15	15	15	15
16	1	1	1
17	17	17	17
18	9	9	9
19	19	19	19
20	5	5	5
21	21	21	21
22	11	11	11
23	23	23	23
24	3	3	3
25	25	25	25
26	13	13	13
27	27	27	27
28	7	7	7
29	29	29	29
30	15	15	15
31	31	31	31
32	1	1	1

Grüße Gerd


P.S.: @StrgAltEntf:
Folgender Teil Deiner "expliziten Funktion" verstehe ich nicht & er ist bestimmt auch für viele andere missverständlich:
\(\max\{k~:~2^k\mid n\}
\)
Variable k hängt für mich im "undefinierten Raum" und "|" kann alles mögliche sein (vermutlich was mit "Teiler" -> aber welche von Wem?).

Kannst Du das mit verständlichen Funktionen ausdrücken
(die wenigstens WolframAlpha oder Mathematica versteht)?
Oder soll das eine umständliche Umschreibung von ggT sein?

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.16 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-09 18:32
hyperG
 

2021-04-08 16:15 - Primentus in Beitrag No. 15 schreibt:
Hallo hyperG,
... Strings mit 9000 Zeichen realisiert hast. Es wundert mich nur, dass Du sagst, Dir genügt das schon. Bei den Datenmengen, die ich sonst von Dir kenne, dachte ich eher an Strings mit mehreren Millionen Zeichen....
LG Primentus

Also gut: Matrix mit 1200 * 1200 uint128 Zahlen = 27091438 Zeichen



Mathematica V12 schlägt sich hier sehr gut mit 2.14 s, weil ALLE 20 Kerne einbezogen werden!

Hingegen benötigt die einfache Array -> String Konvertierung schon 4 s !?!
Kann man
mathematica
A={{12, 345}, {14567099999987654321, 11304444444444444441}};
StringRiffle[Flatten[A], ","]
out
12,345,14567099999987654321,11304444444444444441
noch beschleunigen?

Meine Wandlung mit 1 Kern wandelt {String -> uint128-Array} + rechnet {Matrix-Mul + 128Bit-ToString + sb2@ToString[]} dann zusammen in 6.67 s


Andere Softwarepakete
  
Thema eröffnet von: Wario
Wolfram|Alpha Term mit mehreren Variablen berechnen  
Beitrag No.3 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-09 18:16
hyperG
J

Der Syntax, den Mathematica & WolframAlpha gleichermaßen verstehen lautet:
Mathematica
ReplaceAll[b + d + e + f, {b -> 1, d -> 2,e->3,f->4}]
Out: 10 

Grüße Gerd

P.S.: Eulersche Zahl lautet E
Wenn man verbalen Text eingibt, macht Wolfram manchmal aus dem e ein E

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.14 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-08 12:17
hyperG
 

LibraryLink\LibraryResources\Source

wird stark eingeschränkt sein (wie Du ja auch schon festgestellt hast).

Solche Exoten wie 128 BIT + AVX512 wird man damit nicht erstellen können...

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.13 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-08 12:08
hyperG
 

So, Mittagspause.

Gestern habe ich nun endlich Strings als Übergabetyp hinbekommen, ohne den komplizierten Umweg
 -> MakeNETObject -> Marshal`Copy -> NETObjectToExpression
gehen zu müssen: sb2 = NETNew["System.Text.StringBuilder", (Anzahl der maximal möglichen Stringzeichen)+1]
Bei 9000 Zeichen habe ich aufgehört, das reicht mir -> super schnell!

Diese neue Technik mit der 128-Bit-Welt von cpp (g++ Compiler) verbunden
-> und schon ist man bis zu 80 mal schneller! (alles noch ohne Multithreadding & ohne AVX)!


Wichtig bei Geschwindigkeitstests: kleinste Vergleichsgeschwindigkeit sollte 1 s nicht unterschreiten, da sonst
Schwankungen & Daten-Übergabetechnik mehr Wichtung als eigentlich zu vergleichende Berechnung bekommen.

Als ich weiter testete, war Mathematica manchmal nur 63 mal langsamer. Ob das nun am Cache oder an den Zwischenergebnissen
lag (die ja auch mal in den schnellen 64-Bit Bereich fallen), kann ich nicht sagen.

Mit "AMD ignoriert" meinte ich nur AVX512! AVX (256 Bit) gibt es schon über 10 Jahre & AVX2 (256 Bit Mul + add zusammen)
mindestens 5 Jahre auch bei AMD.

Nun fängt Intel sogar an, die AVX512 bei der 10. Genaration zu verändern (AVX512IFMA52), so dass diese selbst auf meinem i9 (AVX512F) nicht mehr laufen.
Was für eine kurzlebige Zeit...

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.11 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-07 16:53
hyperG
 

2021-04-07 00:18 - Primentus in Beitrag No. 10 schreibt:
... Restriktionen der C-Datentypen liegt, weil Mathematica kann ja an sich schon mit extrem großen Zahlen arbeiten.
...

Große Zahlen ja, aber da gibt es einen sprunghaften Unterschied, sobald man die "Grenzen von double & int64" überschreitet -> dann wird intern mit Hex-Arrays gerechnet, die bei Konvertierung in dezimale Ausgaben einen großen Umrechnungs-Zeitanteil beanspruchen.(aber beim Timing ignoriert werden -> deshalb nutze ich immer AbsoluteTime[] Differenzen für meine Zeitmessungen!)
Genau mit dem internen 127-Bit Zwischenergebnis konnte ich ja überhaupt erst die 38 fache Geschwindigkeit erreichen. Mit dem Datentyp uint128_t (den einige c-Compiler optimiert haben) kann man schön einfach Programme erzeugen (im Gegensatz zu anderen Typen wie in GMP & YMP).
Den größten Unterschied hatte ich ja hier im Forum schon vorgestellt:
Matrix-Multiplikation großer Datenmengen:
- ab Version 12 mit double & 10 Kernen super schnell {leider hat Mathematica nur diesen einen Dot-Befehl optimiert}
- nur 2 Stellen mehr (z.B. N[,18]) -> über 1000 mal langsamer & nur 1 Kern!


2021-04-07 00:18 - Primentus in Beitrag No. 10 schreibt:
...
Zum Beispiel wenn man 2 hoch 100.000.000 und 3 hoch 100.000.000 nimmt und beide Zahlen multipliziert, ermittelt Mathematica in weniger als 30 Sekunden, dass das Ergebnis eine Zahl mit 77815126 Dezimalstellen ist und gibt dabei noch z. B. die 11 Ziffern ab der 50000000. Dezimalstelle aus...

Dein "weniger als 30s" kam mir langsam vor :-)
Also meine Tests:
a) kostenlose Cloud -> This computation has exceeded the memory limit for your plan.
b) i9 mit V12:  in 17.3865196 s
Das geht selbst mit Mathematica schneller, da ja wie oben beschrieben die Wandlung von hex nach dez einen großen Teil der Zeit ausmacht!
Also erst alles hex berechnen -> und dann nur die 11 Ziffern nach dez ausgeben:
mathematica
Quotient[Mod[2^100000000*3^100000000, 10^(77815126 + 1 - 50000000)], 
 10^(77815126 + 1 - 50000000 - 11)]
c) Cloud: 12.0  s
d) i9 V12: 3.13 s

Selbst mit "mehr drumherum" (gewünschte Position; Berechnung der Stellenanzahl; Ausgabe führender Nullen mit PaddedForm[] usw.) bleibt es bei 3.13 s

Mit YMP wird das dann nochmals um einiges schneller und man kann mit genug RAM in Zahlenbereiche vordringen, die so schnell keine andere Software berechnen kann. -> das wäre mal eine schöne Knobelaufgabe :-)
Auch bei YMP macht die hex -> dec Wandlung viel Zeit & RAM aus (bei etwa 20 Mrd. kam ich dann selbst mit 32 GB an die Grenzen).
Wenn nur so um die 11 Stellen nach dec gewandelt werden müssen, sollten mindestens Zwischenergebnisse bis 50 Mrd. drin sein.

Wenn ich Zeit habe, werde ich endlich den String als Übergabetyp für DLLs angehen...

In der Praxis scheint der Datentyp uint128 selten aufzutauchen.
Gerade Grafikkarten reduzieren eher die Stellenanzahl und rechnen nur mit single statt double...

Auch bei den AVX-Befehlen ist bei double oder int64 Schluss :-(

Bei AVX512 können zwar viele "kleine Datentypen" parallel berechnet werden:
__m512i _mm512_mulhi_epu16 (__m512i a, __m512i b)
berechnet
Pascal
FOR j := 0 to 31
	i := j*16
	tmp[31:0] := a[i+15:i] * b[i+15:i]
	dst[i+15:i] := tmp[31:16]
ENDFOR
-> also 32 Multiplikationen (je 16 Bit) mit einem einzigen Maschinenbefehl!
Aber bei double & int64 ist Ende:
__m512i _mm512_mullox_epi64 (__m512i a, __m512i b)
FOR j := 0 to 7
i := j*64
dst[i+63:i] := a[i+63:i] * b[i+63:i]
ENDFOR
 und so richtig habe ich noch keine praktischen Anwendungen gefunden... Außerdem ist das Einsammeln (und Ausgeben) der vielen Variablen in AVX-Register zeitfressend...

AMD ignoriert diesen Typ selbst bei den neusten CPUs komplett.

Grüße Gerd

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.9 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-06 22:55
hyperG
 

Hallo Primentus,

ich habe meine ASM-Funktion MulMod mit 127.1 Bit Zwischenergebnissen in eine cpp-DLL eingebunden.
Damit habe ich dann eine schöne Iterationsschleife gebastelt, um die DLL-Aufrufe zu minimieren.

Zusammen mit Deinem Beispiel 2 "Compile,...CompilationTarget -> "C"
haben wir nun 4 schöne Ergebnisse:



a) Mio. DLL-Aufrufe über Umweg .NET sind "grotten" langsam

b) Mathematica mit 1.18 s war ja die Referenz

c) die optimierte DLL mit 1 Aufruf schafft es 38 mal schneller!
(mit dem LINUX-Code könnte ich noch schneller werden und die 128 Bit als internes Zwischenergebnis voll ausreizen!... und meine 20 Kerne voll nutzen!!)

d) "Compile" bringt hier bei diesen großen Zahlen nichts. (etwas langsamer; )


Zu den Strings als Rückgabeparameter bin ich noch nicht gekommen.
Die müssen nicht mal groß sein. Ich dachte wie im Beitrag 1 an die StringSplit[] Funktion, also DLL-Ausgabe:
"123|456|... n Elemente |999".
Dann könnte ich 128-Bit Zahlen relativ einfach ohne NETObject übergeben und in c direkt damit rechnen...

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.7 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-06 20:04
hyperG
 

Den Datentyp bei DefineDLLFunction konnte ich nun auf "UInt64" erweitern, womit nun statt 2^31 - 1 auch bis 2^64-1 übergeben werden kann!

Während der Berechnung läuft ein 2. Kern beim DLL-Aufruf unter Wolfram.InstallableNET, was bei extremer Häufung (1441619 mal) alles verlangsamt:
mathematica
startT0=AbsoluteTime[];
a64=18446744073709451639;Table[a64=Mod[k*a64,10000000000000000051],{k,18446744073309551000,18446744073310992619}];
Print[k, " | ",a64," in ",AbsoluteTime[]-startT0," s"];
k | 4365759282222754366 in 1.1872199 s
 
DLL:
 
startT0=AbsoluteTime[];
a64=18446744073709451639;Table[a64=MulMod64[k,a64,10000000000000000051],{k,18446744073309551000,18446744073310992619}];
Print[k, " | ",a64," in ",AbsoluteTime[]-startT0," s"];
k | 4365759282222754366 in 169.4125134 s

Man muss dann alles in c optimieren und die Aufrufe minimieren...

Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.6 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-06 19:11
hyperG
 

Hallo Primentus,

vielen DANK!!! Genau so ein Code habe ich gesucht!

Nicht nur, dass da ein VS Solution-File dabei war (einfach 32- oder 64-Bit, oder Debug/Release-Umschaltung), sondern auch noch der Syntax vom Doppel-Pointer für beide Welten (cpp & Mathematica).

Transfer + Berechnung + Zeichnung von 1000 Werten sank von 27.86 s
auf 2.39 s  (Bild links) !


Wenn man ein ganzes Array von 1000 "DismalLunarPrimzahlen" mit 1 Funktionsaufruf überträgt
(nicht verwechseln mit "echten Primzahlen"; auch die Summe dieser ist nicht LunarPrimePi !)
dauert es incl. 2 maliger Wandlung + Ausgabe nur 0.2 s !
mathematica
su = 0; Table[{k, tp = aDismalPrimes[[k]], su += tp}, {k, 99}] // Grid
{
 {1, 0, 0},
 {2, 1, 1},
 {3, 0, 1},
 {4, 1, 2},
 {5, 0, 2},
 {6, 1, 3},
 {7, 0, 3},
 {8, 1, 4},
 {9, 0, 4},
 {10, 0, 4},
 {11, 0, 4},
 {12, 1, 5},
 {13, 0, 5},
 {14, 1, 6},
 {15, 0, 6},
 {16, 0, 6},
 {17, 0, 6},
 {18, 1, 7},
 {19, 0, 7}
...

Allerdings ist der Umweg mit
- NetNew -> Funktionsaufruf -> MakeNETObject -> Marshal`Copy -> NETObjectToExpression
schon höchst umständlich, bis man endlich Mathematica-Befehle anwenden kann. Der RAM-Verbrauch steigt damit etwa um das 4fache...

Wenn ich das mit längeren Strings hinbekomme (kurze gehen schon),
kann man sich den kompletten Umweg über NET... schenken.




Mathematica
Universität/Hochschule 
Thema eröffnet von: hyperG
Verbindung der C-Welt mit der Mathematica-Welt  
Beitrag No.4 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-05 21:39
hyperG
 

Danke Primentus.

Dein Run ist ja ähnlich zum
ToExpression@RunProcess[{$LunarArithmeticRuntimePath,"mul",ToString...
was mir aber zu langsam ist.

Auch vom CUDA bin ich etwas enttäuscht, da es oft langsamer als meine schnelle CPU ist.

Alles was mit internen Compiler zu tun hat, bring nur sehr selten Vorteile. Die parallelen Code-Beispiele funktionieren meist, aber sobald man etwas abweicht, erreicht man oft nicht mal Geschwindigkeitsfaktor 2.

Was für mich das meiste Potential hat, ist die unter Beitrag 1 & 2 vorgestellte
DefineDLLFunction
wo ich meine selbst optimierten Cpp DLL einbinden kann:
- 128 Bit Ganzzahl Technik (da wird Mathematica schlagartig langsam)
- AVX2 & AVX512, was nur wenige Compiler & Assembler können
- Multitasking
- YMP Bibliothek (besonders ab 1 Mio. zig mal schneller )
- keine Verzögerung beim Starten von Prozessen (mit Run...)

Grüße Gerd

Funktionen
  
Thema eröffnet von: Pamfax
Funktion gesucht  
Beitrag No.7 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-05 21:02
hyperG
 

Ich hatte hier ja schon mal die LevelIndexArithmetic
vorgestellt.
Damit lässt sich PowVG[4]=A173566[5]
in 10er Potenzschreibweise darstellen:
mathematica
LevelIndexArithmetic[(256^256)^(256^256)] // FromLIO
10^10^(10^10^0.44589995808177951847595729333888544828864939472940037727367073716847...)
=10^(1.99237390285201540877064229451470146529162235290594558297395462...*10^619)

Also eine Zahl mit fast 2*10^619 (2E619) Stellen.
Da das Weltall nur etwa 10^80 (1E80) Atome hat, kann man sie nie in Dezimalschreibweise ganz exakt aufschreiben!



Mehr als 10^539 Ziffern pro Atom :-)

Funktionen
  
Thema eröffnet von: Pamfax
Funktion gesucht  
Beitrag No.5 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-05 20:29
hyperG
 

Unter OEIS lautet sie
oeis.org/A173566

Man kann also auch
f(n)=A173566[n]
schreiben -> und alle wissen, was gemeint ist.

PowVG[n]=A173566[n+1]
da ich den Index 0 auf Funktionswert 2 festgelegt hatte.
A173566[0]=e^ProductLog(log(2))=1.559610469462369349970388768765002993284883511843...




Funktionen
  
Thema eröffnet von: Pamfax
Funktion gesucht  
Beitrag No.4 im Thread
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag2021-04-05 20:04
hyperG
 

Wenn der Startwert statt 2 eine 10 ist:
10
10^10
(10^10)^(10^10)=10^10^11
ähnelt sie en.wikipedia.org/wiki/Double_exponential_function
aber das wäre 10^10^n (steigt also langsamer) als gewünscht...

Eine Liste von Rekursionen mit Eigennamen findet man hier:
googology.wikia.org/wiki/List_of_functions#Primitive_recursive
 

Sie haben sehr viele Suchergebnisse
Bitte verfeinern Sie die Suchkriterien

[Die ersten 20 Suchergebnisse wurden ausgegeben]
Link auf dieses Suchergebnis hier
(noch mehr als 20 weitere Suchergebnisse)

-> [Suche im Forum fortsetzen]
 
 

 
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]

used time 0.068354