Real GeneralizedOrnsteinUhlenbeckProcess::variance(
                                              Time t, Real, Time dt) const {
        Real speed = speed_(t);
        Volatility vol = volatility_(t);

        if (speed < std::sqrt(QL_EPSILON)) {
            // algebraic limit for small speed
            return vol*vol*dt;
        } else {
            return 0.5*vol*vol/speed*(1.0 - std::exp(-2.0*speed*dt));
        }
    }
Animation::Animation(unsigned int rng_seed, float scale) : rng_(rng_seed), dir_(-1.0f, 1.0f), speed_(0.1f, 1.0f) {
    float x = dir_(rng_);
    float y = dir_(rng_);
    float z = dir_(rng_);
    if (std::abs(x) + std::abs(y) + std::abs(z) == 0.0f) x = 1.0f;

    current_.axis = glm::normalize(glm::vec3(x, y, z));

    current_.speed = speed_(rng_);
    current_.scale = scale;

    current_.matrix = glm::scale(glm::mat4(1.0f), glm::vec3(current_.scale));
}
 Real GeneralizedOrnsteinUhlenbeckProcess::speed(Time t) const {
     return speed_(t);
 }
 Real GeneralizedOrnsteinUhlenbeckProcess::expectation(
                                          Time t, Real x0, Time dt) const {
     return level_ + (x0 - level_) * std::exp(-speed_(t)*dt);
 }
 Real GeneralizedOrnsteinUhlenbeckProcess::drift(Time t, Real x) const {
     return speed_(t) * (level_ - x);;
 }