In der Wahrscheinlichkeitstheorie ist die Normalverteilung (oder Gaußsche Verteilung) eine sehr häufige kontinuierliche Wahrscheinlichkeitsverteilung. Normalverteilungen sind in der Statistik wichtig und werden in den Natur- und Sozialwissenschaften häufig verwendet, um reelle Zufallsvariablen darzustellen, deren Verteilungen nicht bekannt sind.

Die Herausforderung

Ihre Herausforderung besteht darin, die Wahrscheinlichkeitsdichte der Gaußschen Verteilung auf einer dreidimensionalen Ebene darzustellen . Diese Funktion ist definiert als:

Wo:

A = 1, σ _x = σ _y = σ

Regeln

• Ihr Programm muss eine Eingabe σ , die Standardabweichung, annehmen .
• Ihr Programm muss ein 3D-Diagramm der Gaußschen Verteilung in der höchsten Qualität drucken, die Ihre Sprache / Ihr System zulässt.
• Ihr Programm verwendet möglicherweise keine direkte integrierte Gaußsche Verteilung oder Wahrscheinlichkeitsdichte.
• Ihr Programm muss nicht beendet werden.
• Ihr Plot kann in Schwarzweiß oder Farbe sein.
• Ihr Plot muss unten Gitterlinien haben. Gitterlinien an den Seiten (wie in den Beispielen gezeigt) sind nicht erforderlich.
• Ihr Plot muss keine Zeilennummern neben den Gitterlinien haben.

Wertung

Wie beim Code-Golf üblich , gewinnt die Einreichung mit den wenigsten Bytes! Ich kann niemals eine Antwort mit der Schaltfläche "akzeptieren", es sei denn, eine ist unglaublich klein und intuitiv.

Beispielausgabe

Ihre Ausgabe könnte ungefähr so ​​aussehen:

Oder es könnte so aussehen:

Weitere gültige Ausgaben . Ungültige Ausgaben .

Gnuplot 4, 64 62 61 60 47 Bytes

(Gebunden mit Mathematica ! WooHoo!)

se t pn;se is 80;sp exp(-(x**2+y**2)/(2*$0**2))

Speichern Sie den obigen Code in einer Datei mit dem Namen A.gpund rufen Sie ihn wie folgt auf:

gnuplot -e 'call "A.gp" $1'>GnuPlot3D.png

wo das $1durch den Wert von ersetzt werden soll σ. Dadurch wird eine .pngDatei GnuPlot3D.pngmit dem Namen mit der gewünschten Ausgabe im aktuellen Arbeitsverzeichnis gespeichert .

Beachten Sie, dass dies nur mit Distributionen von Gnuplot 4 funktioniert, da in Gnuplot 5 die $nVerweise auf Argumente veraltet waren und durch die leider ausführlicheren ersetzt wurden ARGn.

Beispielausgabe mit σ = 3:

Diese Ausgabe ist laut OP in Ordnung .

Gnuplot 4, alternative Lösung, 60 Bytes

Hier ist eine alternative Lösung, die viel länger ist als die vorherige, aber die Ausgabe sieht meiner Meinung nach viel besser aus.

se t pn;se is 80;se xyp 0;sp exp(-(x**2+y**2)/(2*$0**2))w pm

Dies erfordert Gnuplot 4 aus demselben Grund wie die vorherige Lösung.

Beispielausgabe mit σ = 3:

C ++, 3477 3344 Bytes

^{Die Byteanzahl enthält nicht die unnötigen Zeilenumbrüche.
MD XF spielte 133 Bytes ab.}

C ++ kann auf keinen Fall damit konkurrieren, aber ich dachte, es würde Spaß machen, einen Software-Renderer für die Herausforderung zu schreiben. Ich riss einige GLM- Stücke heraus und spielte sie für die 3D-Mathematik und verwendete den Linienalgorithmus von Xiaolin Wu für die Rasterung. Das Programm gibt das Ergebnis in eine PGM-Datei mit dem Namen aus g.

#include<array>
#include<cmath>
#include<vector>
#include<string>
#include<fstream>
#include<algorithm>
#include<functional>
#define L for
#define A auto
#define E swap
#define F float
#define U using
U namespace std;
#define K vector
#define N <<"\n"
#define Z size_t
#define R return
#define B uint8_t
#define I uint32_t
#define P operator
#define W(V)<<V<<' '
#define Y template<Z C>
#define G(O)Y vc<C>P O(vc<C>v,F s){vc<C>o;L(Z i=0;i<C;++i){o\
[i]=v[i]O s;}R o;}Y vc<C>P O(vc<C>l, vc<C>r){vc<C>o;L(Z i=0;i<C;++i){o[i]=l[i]O r[i];}R o;}
Y U vc=array<F,C>;U v2=vc<2>;U v3=vc<3>;U v4=vc<4>;U m4=array<v4,4>;G(+)G(-)G(*)G(/)Y F d(
vc<C>a,vc<C>b){F o=0;L(Z i=0;i<C;++i){o+=a[i]*b[i];}R o;}Y vc<C>n(vc<C>v){R v/sqrt(d(v,v));
}v3 cr(v3 a,v3 b){R v3{a[1]*b[2]-b[1]*a[2],a[2]*b[0]-b[2]*a[0],a[0]*b[1]-b[0]*a[1]};}m4 P*(
m4 l,m4 r){R{l[0]*r[0][0]+l[1]*r[0][1]+l[2]*r[0][2]+l[3]*r[0][3],l[0]*r[1][0]+l[1]*r[1][1]+
l[2]*r[1][2]+l[3]*r[1][3],l[0]*r[2][0]+l[1]*r[2][1]+l[2]*r[2][2]+l[3]*r[2][3],l[0]*r[3][0]+
l[1]*r[3][1]+l[2]*r[3][2]+l[3]*r[3][3]};}v4 P*(m4 m,v4 v){R v4{m[0][0]*v[0]+m[1][0]*v[1]+m[
2][0]*v[2]+m[3][0]*v[3],m[0][1]*v[0]+m[1][1]*v[1]+m[2][1]*v[2]+m[3][1]*v[3],m[0][2]*v[0]+m[
1][2]*v[1]+m[2][2]*v[2]+m[3][2]*v[3],m[0][3]*v[0]+m[1][3]*v[1]+m[2][3]*v[2]+m[3][3]*v[3]};}
m4 at(v3 a,v3 b,v3 c){A f=n(b-a);A s=n(cr(f,c));A u=cr(s,f);A o=m4{1,0,0,0,0,1,0,0,0,0,1,0,
0,0,0,1};o[0][0]=s[0];o[1][0]=s[1];o[2][0]=s[2];o[0][1]=u[0];o[1][1]=u[1];o[2][1]=u[2];o[0]
[2]=-f[0];o[1][2]=-f[1];o[2][2]=-f[2];o[3][0]=-d(s,a);o[3][1]=-d(u,a);o[3][2]=d(f,a);R o;}
m4 pr(F f,F a,F b,F c){F t=tan(f*.5f);m4 o{};o[0][0]=1.f/(t*a);o[1][1]=1.f/t;o[2][3]=-1;o[2
][2]=c/(b-c);o[3][2]=-(c*b)/(c-b);R o;}F lr(F a,F b,F t){R fma(t,b,fma(-t,a,a));}F fp(F f){
R f<0?1-(f-floor(f)):f-floor(f);}F rf(F f){R 1-fp(f);}struct S{I w,h; K<F> f;S(I w,I h):w{w
},h{h},f(w*h){}F&P[](pair<I,I>c){static F z;z=0;Z i=c.first*w+c.second;R i<f.size()?f[i]:z;
}F*b(){R f.data();}Y vc<C>n(vc<C>v){v[0]=lr((F)w*.5f,(F)w,v[0]);v[1]=lr((F)h*.5f,(F)h,-v[1]
);R v;}};I xe(S&f,v2 v,bool s,F g,F c,F*q=0){I p=(I)round(v[0]);A ye=v[1]+g*(p-v[0]);A xd=
rf(v[0]+.5f);A x=p;A y=(I)ye;(s?f[{y,x}]:f[{x,y}])+=(rf(ye)*xd)*c;(s?f[{y+1,x}]:f[{x,y+1}])
+=(fp(ye)*xd)*c;if(q){*q=ye+g;}R x;}K<v4> g(F i,I r,function<v4(F,F)>f){K<v4>g;F p=i*.5f;F
q=1.f/r;L(Z zi=0;zi<r;++zi){F z=lr(-p,p,zi*q);L(Z h=0;h<r;++h){F x=lr(-p,p,h*q);g.push_back
(f(x,z));}}R g;}B xw(S&f,v2 b,v2 e,F c){E(b[0],b[1]);E(e[0],e[1]);A s=abs(e[1]-b[1])>abs
(e[0]-b[0]);if(s){E(b[0],b[1]);E(e[0],e[1]);}if(b[0]>e[0]){E(b[0],e[0]);E(b[1],e[1]);}F yi=
0;A d=e-b;A g=d[0]?d[1]/d[0]:1;A xB=xe(f,b,s,g,c,&yi);A xE=xe(f,e,s,g,c);L(I x=xB+1;x<xE;++
x){(s?f[{(I)yi,x}]:f[{x,(I)yi}])+=rf(yi)*c;(s?f[{(I)yi+1,x}]:f[{x,(I)yi+1}])+=fp(yi)*c;yi+=
g;}}v4 tp(S&s,m4 m,v4 v){v=m*v;R s.n(v/v[3]);}main(){F l=6;Z c=64;A J=g(l,c,[](F x,F z){R
v4{x,exp(-(pow(x,2)+pow(z,2))/(2*pow(0.75f,2))),z,1};});I w=1024;I h=w;S s(w,h);m4 m=pr(
1.0472f,(F)w/(F)h,3.5f,11.4f)*at({4.8f,3,4.8f},{0,0,0},{0,1,0});L(Z j=0;j<c;++j){L(Z i=0;i<
c;++i){Z id=j*c+i;A p=tp(s,m,J[id]);A dp=[&](Z o){A e=tp(s,m,J[id+o]);F v=(p[2]+e[2])*0.5f;
xw(s,{p[0],p[1]},{e[0],e[1]},1.f-v);};if(i<c-1){dp(1);}if(j<c-1){dp(c);}}}K<B> b(w*h);L(Z i
=0;i<b.size();++i){b[i]=(B)round((1-min(max(s.b()[i],0.f),1.f))*255);}ofstream f("g");f 
W("P2")N;f W(w)W(h)N;f W(255)N;L(I y=0;y<h;++y){L(I x=0;x<w;++x)f W((I)b[y*w+x]);f N;}R 0;}

• l ist die Länge einer Seite des Gitters im Weltraum.
• c ist die Anzahl der Eckpunkte entlang jeder Kante des Gitters.
• Die Funktion, die das Gitter erstellt, wird mit einer Funktion aufgerufen, die zwei Eingaben akzeptiert, die xund z(+ y geht nach oben) Weltraumkoordinaten des Scheitelpunkts und die Weltraumposition des Scheitelpunkts zurückgibt.
• w ist die Breite des pgm
• h ist die Höhe des pgm
• mist die Ansichts- / Projektionsmatrix. Die zum Erstellen verwendeten Argumente msind ...
  • Sichtfeld im Bogenmaß
  • Seitenverhältnis der pgm
  • in der Nähe der Clip-Ebene
  • weit Clip Ebene
  • Kameraposition
  • Kamera Ziel
  • up Vektor

Der Renderer könnte leicht mehr Funktionen, eine bessere Leistung und ein besseres Golfspiel haben, aber ich hatte meinen Spaß!

Mathematica, 47 Bytes

Plot3D[E^(-(x^2+y^2)/2/#^2),{x,-6,6},{y,-6,6}]&

nimmt als Eingabe σ

Eingang

[2]

Ausgabe

-2 Bytes dank LLlAMnYP

R, 105 102 87 86 Bytes

s=scan();plot3D::persp3D(z=sapply(x<-seq(-6,6,.1),function(y)exp(-(y^2+x^2)/(2*s^2))))

Nimmt Sigma von STDIN. Erstellt einen Vektor aus , -6um 6in Schritten von .1sowohl xund y, erstellt dann eine 121x121Matrix , die durch das äußere Produkt der Einnahme xund y. Dies ist kürzer als das Aufrufen matrixund Festlegen der Dimensionen. Die Matrix ist jetzt bereits gefüllt, aber das ist in Ordnung, weil wir das überschreiben.

Die forSchleife durchläuft die Werte in x, wobei die vektorisierten Operationen in verwendet Rwerden und die Dichtematrix zeilenweise erstellt wird.

(s)applywieder ist eine kürzere Methode für vektorisierte Operationen. Wie der Held, der es ist, übernimmt er die Erstellung der Matrix ganz alleine und spart einige Bytes.

128 125 110 109 Bytes, aber viel ausgefallener:

Dieses Diagramm wird vom plotlyPaket erstellt. Leider ist die Spezifikation etwas wortreich, so dass dies viele Bytes kostet. Das Ergebnis ist wirklich sehr, sehr schick. Ich würde es wärmstens empfehlen, es selbst auszuprobieren.

s=scan();plotly::plot_ly(z=sapply(x<-seq(-6,6,.1),function(y)exp(-(y^2+x^2)/(2*s^2))),x=x,y=x,type="surface")

Applesoft BASIC, 930 783 782 727 719 702 695 637 Bytes

^{-72 Bytes und ein funktionierendes Programm dank Ceilingcat, das meinen Fehler entdeckt, und eines verkürzten Algorithmus}

0TEXT:HOME:INPUTN:HGR:HCOLOR=3:W=279:H=159:L=W-100:Z=L/10:B=H-100:C=H-60:K=0.5:M=1/(2*3.14159265*N*N):FORI=0TO10STEPK:X=10*I+1:Y=10*I+B:HPLOTX,Y:FORJ=0TOL STEP1:O=10*J/L:D=ABS(5-I):E=ABS(5-O):R=(D*D+E*E)/(2*N*N):G=EXP(-R)*M:A=INT((C*G)/M):X=10*I+Z*O+1:Y=10*I+B-A:HPLOTTOX,Y:IF(I=0)GOTO4
1IF(J=L)GOTO3
2V=INT(J/10):IF((J/10)<>V)GOTO5
3D=ABS(5-I+K):E=ABS(5-O):R=(D*D+E*E)/(2*N*N):U=EXP(-R)/(2*3.14159*N*N):S=INT((C*U)/M):P=10*(I-K)+Z*O+1:Q=10*(I-K)+B-S:HPLOT TOP,Q:HPLOTX,Y
4IF(J=0)GOTO7:IF(I<10)GOTO5:IF(J=L)GOTO6:V=INT(J/10):IF((J/10)=V)GOTO6
5HCOLOR=0
6HPLOTTOX,10*I+B:HCOLOR=3:HPLOTX,Y
7NEXTJ:NEXTI:HPLOTW+1,H:HPLOTTO101,H:HPLOTTO0+1,H

Ungolfed Version hier.

Bei Eingabe 1:

Bei Eingabe 2: