Preis Steigerung per zufall

Matyr

Hi,
Ich habe ein Problem. Ich möchte gerne die Preissteigerung eines Produktes simulieren, mein Problem ist ich weiß nicht wie.
Ich habe schon eine gute zufall´s lib runtergeladen, und einige algorithmen die ich mir ausgedacht habe getestet aber nichts funktioniert zufriedenstellend.

Mein Ziel ist es das man den Startpreis eines Produktes fest eingeben kann, nun soll stündlich per zufall der Preis sinken oder steigen aber wirklich nur minimal. Die gesamt tendenz soll SHER LEICHT nach oben sein. Inprinzip soll das wenn es in einem Diagramm dargestellt wird wie der Ölpreis aussehen. ZickZack mit leichtem kurs nach oben.

Bei meinen versuchen war das eher ein masives fallen und anschließendes steigen oder ähnlich und der Preis hat sich innerhalb von weniger als 100tagen verdoppelt was viel zu viel ist.

Mfg. Matyr

SideWinder

Fällt/Steigt der Wert zu stark dann führe einfach einen Faktor ein, um welchen du das Fallen/Steigen verringerst.

MfG SideWinder

XHansWurstX

Du könntest dir einen Counter einbauen, wie es die Kartenzähler beim Black-Jack machen. Je nachdem, ob der Preis steigt oder fällt, wird addiert oder subtrahiert.

Matyr

Habe ich schon getestet, aber bringt nichts weil das passieren kann das dann 100 und mehr werte hintereinander fallen. Auch wenn ich da eine begrenzung reinsetze steigt das einmal wieder und fällt dan z.B. weiter.

Und bei 100000h bzw. rechendurchläufen passiert sowas mal. Und das ist dann leider mist.

Mfg. Matyr

Ps. trozdem Danke

Fellhuhn

Du nimmst zwei Werte:
a) deine Tendenz (zB Steigung von 0,5 über Zeit)
b) deine Abweichung (zB 0,9, niedriger als Tendenz*2)

nun rechnest du einen Zufallswert von 0 bis Abweichung und dann:
AktuellerWert + Tendenz + Abweichung

Im Schnitt erreichst du so eine Abweichung von 0,45 und bei einer Tendenz von 0,5 erreichst du eine durchschnittliche Steigerung von 0,05

Matyr

Was meinst du mit der Abweichung?

Also ich gebe eine preissteigerungs tendenz vor, hohle mir dann eine Zufäälige Zahl und anschließend vergleich ich die? oder wie?

Mfg. matyr

Fellhuhn

Rechnest du dir selber aus.

Bei einer "Tendenz" von T und einer "Abweichung" von A mit A < 2*T hast du eine durchschnittliche Steigerung von T-A/2.
T und A wählst du, so wie du es im Endeffekt haben willst.

Wenn du eine Steigung von 100 willst, musst du T und A nur so wählen das T-A/2 == 100 ist.

Der maximale Abfall ist A-T.

Was Du suchst ist doch eine normal verteilte zufällige Steigung.

Die lässt sich aus zwei gleich verteilten Zufallszahlen simulieren.

http://de.wikipedia.org/wiki/Normalverteilung#Simulation_normalverteilter_Zufallsvariablen

Matyr

Die Normalverteilung sieht ziemlich nach dem aus was ich brauchen könnte,
jetzt muss ich nurnoch wissen wie ich das programiertechnisch umsetze.
Bzw. ob es vieleicht an meine zufalls lib liegt das die doch net so gut ist.

Der Wiki Artikel ist wohl schön und gut nur leider verstehe ich da großteils nur bahnhof.

Werner Salomon

Hallo Matyr,

Du könntest die Kurve auch als das Resultat eines Ein-Masse-Schwingers darstellen, der durch zufällige Störungen angeregt wird. Das lässt sich leicht numerisch nachstellen.
Folgender Code als Beispiel:

#include <iostream>
#include <iomanip>
#include "Zufall.h"

class Preis
{
public:
    explicit Preis( double value ) 
        : m_value( value ), m_tendenz( m_value ), m_steigerung( 0.0 ) {}
    void tick()
    {
        // Zeit vergeht.
        m_tendenz += 0.1;                               // die Zunahme der Tendenz ist die Steigung pro Tick

        m_steigerung *= 0.85;                           // Dämpfung; sollte etwas kleiner als 1 sein
        m_steigerung -= (m_value - m_tendenz) * 0.1;    // Rückholfeder (bestimmt die 'Wellenlänge') 0.1 := 20ticks
        m_steigerung += Zufall< double >( -1.0, +1.0 )() * 0.70;    // 'Zitterfaktor'
        m_value += m_steigerung;
    }
    friend std::ostream& operator<<( std::ostream& out, const Preis& preis )
    {
        return out << std::fixed << std::setprecision(2) << std::setw(8) << preis.m_value
            << std::setw(int(3*preis.m_value)) << ".";
    }

private:
    double m_value;
    double m_tendenz;
    double m_steigerung;
};

int main()
{
    using namespace std;
    Preis preis( 10.0 );
    for( int i=0; i< 50; ++i, preis.tick() )
    {
        cout << preis << endl;
    }
    return 0;
};

Die Datei "Zufall.h" findest Du hier.
Mit der Steigerung der Tendenz wird die mittlere Preissteigerung angegeben.
Mit den drei Konstanten Dämpfung, Rückholfeder und Zitterfaktor kannst Du die Kurve charakterisieren. Mit der 'Rückholfeder' gibst Du die mittlere Wellenlänge vor. Es gilt im Prinzip die Formel:

c = (2*PI/wellenlaenge)^2

wobei die wellenlänge in Anzahl Ticks anzugeben ist. Bei 20 Ticks kommt also etwa 0.1 heraus.
Umso höher Du den Zitterfaktor aufdrehst, umso mehr verliert die Kurve ihre Wellenform. Dieser Wert sollte zu Deinem Preis passen. Und umso mehr Dämpfung Du hinzugibst (der Wert muss dazu verkleinert werden - weniger ist hier mehr) umso mehr dämpfst Du wiederum die Bewegungen.

Hier ein Beispiel für die geposteten Werte:

10.00                             .
    9.39                           .
    9.11                          .
    9.62                           .
    9.69                            .
    9.86                            .
   10.03                             .
    9.71                            .
    8.97                         .
    8.59                        .
    8.35                        .
    9.04                          .
    9.36                           .
    9.26                          .
    9.18                          .
    9.21                          .
   10.08                             .
   11.09                                .
   12.17                                   .
   12.38                                    .
   12.85                                     .
   13.69                                        .
   14.44                                          .
   14.63                                          .
   14.44                                          .
   14.20                                         .
   13.94                                        .
   13.44                                       .
   13.57                                       .
   14.12                                         .
   13.89                                        .
   14.01                                         .
   13.91                                        .
   13.56                                       .
   12.88                                     .
   12.28                                   .
   12.45                                    .
   13.25                                      .
   14.54                                          .
   15.47                                             .
   15.45                                             .
   15.19                                            .
   15.28                                            .
   15.94                                              .
   15.74                                              .
   15.75                                              .
   16.16                                               .
   16.15                                               .
   16.27                                               .
   15.93                                              .

probiere es selber mal.

Gruß
Werner

It0101

Du könntest auch zuallererst mit einer linearen Funktion die Steigung erzeugen, und erst danach auf jeden Wert dieser linearen Funktion irgendwelche Zufallszahlen addieren oder subtrahieren.

Matyr

Vielen Dank Werner Salomon, ich verstehe wohl nicht ganz wie das funktioniert aber auf jedenfall sieht das ziemlich gut aus.

Ich lese mir das ganze nochmal langsam durch und versuche es zu verstehen.

Nochmal Danke
& Mfg. Matyr