Das ist bisher das schnellste was ich hinbekommen hab.
Obwohl es im Raum eine menge Null-Chancen-Positionen gibt. Die Menge der Fehlversuche ist ziemlich enorm.

Ich hatte ursprünglich versucht alle Positionen incl. Chance in eine Liste zu speichern, eine Zufallszahl zu erzeugen (Null bis <Summe aller Chancen> )
und die dann solange durch zu gehen bis zur richtigen Position.
Dadurch dass ich die Null-Chancen von vornherein aus der Liste ausschließen konnte ging das auch einigermaßen Fix.
Das Erebnis ist auch gut.

Aber Brute-Force ist überraschenderweise trotzdem schneller.

Ich kann mir nicht vorstellen dass dass das schnellstmögliche ist. Aber alles was mir sonst noch eingefallen ist, ist langsamer oder liefert ein völlig anderes Ergebnis.

Hat jemand evtl nen Denkanreiz?

Ich gehe bei obigem Tipp übrigens davon aus, dass du unabhängige Zufallszahlen aus deiner Verteilung ziehen möchtest. Wenn du einfach eine Punktwolke nach deiner Verteilung erzeugen möchtest, egal in welcher Reihenfolge die Einzelpunkte erzeugt werden, könnte man, je nachdem wie wild die Verteilung ist, eventuell auch eine Monte-Carlo artige Erzeugungstechnik in Erwägung ziehen.

Oh, noch ne Idee.
Wenn du MAX_CHANCE fließkommamäßig lassen willst, könntest du jeder erlaubten x-y-z-Kombination einen Bereich, der entsprechen der Wahrscheinlichkeit für den Punkt groß ist, in den Fließkommazahlen von 0 bis irgendwas zuweisen, die dann eine von 0 bis irgendwas erzeugen lassen und gucken, welchen deiner Kandidaten sie trifft.

Geht natürlich beides nur für recht kleine Mengen. SeppJs Ansatz ist natürlich skalierbarer, allgemeingültiger und eleganter.

Moin!

Ich hatte ursprünglich versucht alle Positionen incl. Chance in eine Liste zu speichern

Ich hoffe, es war keine Liste. Das wäre ziemlich doof.

Mein Ansatz wäre: wie du es gemacht hast, einen Vektor erzeugen. Allerdings mit der akkumulierten Wahrscheinlichkeit. Der erste Wert im Vector hat also irgendeine echt kleine zahl, der letzte ist 1. Und dann eine Binäre suche machen:

std::vector<double> accList; //accList[i]= p[0]+p[1]+...+p[i]
std::vector<Vector> coords; //coords[i] liefert die Position für das element i
//initialisiere lustig deine Liste...)

//algorithmus:
Vector draw(){
    double p = uniform();
    std::size_t minElem = 0;
    std::size_t maxElem = coords.size();
    while(minElem != maxElem){
        std::size_t pos = (maxElem-minElem)/2;
        if(p > accList[i]){
            minElem = pos;
        }
        else
        {
            maxElem = pos;
        }
    }
    //hier gilt miNElem=maxElem = das gesuchte Element
    return coords[minElem];
}

ich bin mir gerade nicht 100% mit den indizes sicher, vielleicht muss man noch etwas daran rumdrehen, dass ja jedes Element ein Wahrscheinlichkeitsintervall darstellt...aber vom Prinzip her sollte da sklappen. Noch fixer wäre es, wenn du nen richtigen baum konstruierst, der die Wahrscheinlichkeiten auch in der Suchstruktur widerspiegelt. Meine Konstruktion sucht nach nem Knoten mit p=0.5 genauso lange wie bei einem p=0.00001 Knoten.

Die Monte-Carlo Sache gefällt mir. Gutes Beispiel für Irgendwann mal gelesen ums im richtigen Moment vergessen zu haben.

Leider langsamer. Kann vielleicht an der falschen Umsetzung liegen...

void Galaxy::AddStars3 (UINT nStars, perlin::Noise3D* pNoise)
{
	lblArray3<float> aPositions (m_fWidthX, m_fWidthY, m_fWidthZ);
	for (UINT nCreated = 0; nCreated < nStars; )
	{
		UINT nRandRainX = Rand<UINT> (0, (UINT)m_fWidthX),
		     nRandRainY = Rand<UINT> (0, (UINT)m_fWidthY),
		     nRandRainZ = Rand<UINT> (0, (UINT)m_fWidthZ);

		float* pfData = aPositions(nRandRainX, nRandRainY, nRandRainZ);
		if (*pfData < 0.0f) // Position bereits verwendet.
			continue;

		*pfData += pNoise->Get (nRandRainX, nRandRainY, nRandRainZ);
		if (*pfData >= 1.0f) /* vielleicht auch höher als 1.0. Ausprobieren...*/
		{
			D3DXVECTOR3 vStarPos ((float)nRandRainX,
								  (float)nRandRainY,
								  (float)nRandRainZ);

			m_pStarTree->insert (new star (vStarPos));

			*pfData = -1.0f; // als 'verwendet' markieren
		}
	}

(Die Noise-Funktion liefert Werte zwischen 0 und 1)

Ihr anderen habt auch gute Ideen aber die hab ich jetzt noch nicht ausprobiert weil: Wenn schon Monte-Carlo (der ohne Listen aufbauen) auskommt langsamer ist, hab ich kaum Hoffnung daß das irgendwie weiterhilft...

im Moment zumindest.

Das ist bisher das schnellste was ich hinbekommen hab.
Obwohl es im Raum eine menge Null-Chancen-Positionen gibt. Die Menge der Fehlversuche ist ziemlich enorm.

Wenn sogar MC langsamer ist: was ist für dich "enorm"? Enorm beginnt für mich bei >10^5 Fehlversuchen pro Treffer.