// [[Rcpp::export]]
Rcpp::List asianOptionEngine(std::string averageType,
std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double first,
double length,
size_t fixings) {
QuantLib::Option::Type optionType = getOptionType(type);
//from test-suite/asionoptions.cpp
QuantLib::DayCounter dc = QuantLib::Actual360();
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new
QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
boost::shared_ptr<QuantLib::StrikedTypePayoff>
payoff(new QuantLib::PlainVanillaPayoff(optionType,strike));
Rcpp::List rl = R_NilValue;
if (averageType=="geometric"){
boost::shared_ptr<QuantLib::PricingEngine>
engine(new
QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine(stochProcess));
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
QuantLib::Date exDate(today.dateTime() + boost::posix_time::minutes(maturity * 360 * 24 * 60));
#else
QuantLib::Date exDate = today + int(maturity * 360 + 0.5);
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
QuantLib::ContinuousAveragingAsianOption option(QuantLib::Average::Geometric,
payoff, exercise);
option.setPricingEngine(engine);
rl = Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = option.vega(),
Rcpp::Named("theta") = option.theta(),
Rcpp::Named("rho") = option.rho(),
Rcpp::Named("divRho") = option.dividendRho());
} else if (averageType=="arithmetic") {
// TODO: check fixings > 1, first, length
if (first < 0) Rcpp::stop("Parameter 'first' must be non-negative.");
if (length < 0) Rcpp::stop("Parameter 'length' must be non-negative.");
if (fixings <= 1) Rcpp::stop("Parameter 'fixings' must be larger than one.");
boost::shared_ptr<QuantLib::PricingEngine> engine =
QuantLib::MakeMCDiscreteArithmeticAPEngine<QuantLib::LowDiscrepancy>(stochProcess)
.withSamples(2047)
.withControlVariate();
//boost::shared_ptr<PricingEngine> engine =
// MakeMCDiscreteArithmeticASEngine<LowDiscrepancy>(stochProcess)
// .withSeed(3456789)
// .withSamples(1023);
QuantLib::Time dt = length / (fixings - 1);
std::vector<QuantLib::Time> timeIncrements(fixings);
std::vector<QuantLib::Date> fixingDates(fixings);
timeIncrements[0] = first;
fixingDates[0] = today + QuantLib::Integer(timeIncrements[0] * 360 + 0.5);
for (QuantLib::Size i=1; i<fixings; i++) {
timeIncrements[i] = i*dt + first;
#ifdef QL_HIGH_RESOLUTION_DATE
fixingDates[i]= QuantLib::Date(today.dateTime() + boost::posix_time::minutes(timeIncrements[i] * 360 * 24 * 60));
#else
fixingDates[i] = today + QuantLib::Integer(timeIncrements[i]*360+0.5);
#endif
}
QuantLib::Real runningSum = 0.0;
QuantLib::Size pastFixing = 0;
boost::shared_ptr<QuantLib::Exercise>
exercise(new QuantLib::EuropeanExercise(fixingDates[fixings-1]));
QuantLib::DiscreteAveragingAsianOption option(QuantLib::Average::Arithmetic,
runningSum,
pastFixing,
fixingDates,
payoff,
exercise);
option.setPricingEngine(engine);
rl = Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = R_NaReal,
Rcpp::Named("gamma") = R_NaReal,
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
}
return rl;
}
void game::run()
{
//MissileDesc projectile(*this);
towerDesc towr(this);
std::string txt;
std::string txt2 = "Life:";
std::string txt3 = "Money:";
std::string main = "Cam Pos";
std::string txt4 = "Game Over";
std::list<SceneObject *> troll;
endgame = false;
mouseUp = false;
float dir = 0.0f;
float spot_dir = 45.0f;
float aspect_time = 0.0f;
towerCount = 0;
cost = 0;
life = 20;
money = 10;
quit = false;
cameraRestricted = false;
selected_tower = "";
std::stringstream ss2 (std::stringstream::in | std::stringstream::out);
std::stringstream ss3 (std::stringstream::in | std::stringstream::out);
/*GUI app;
int retval = app.main(args);
if (retval == 0)
{
return retval;
}*/
Quaternionf camera_orientation(55.0f, 0.0f, 0.0f, angle_degrees, order_YXZ);
clan::OpenGLWindowDescription opengl_desc;
opengl_desc.set_version(3, 2, false);
clan::OpenGLTarget::set_description(opengl_desc);
//Scene test;
//clan::SceneCamera camera(test);
//DisplayWindowDescription innerwindow("Hello World", Size(640, 480), true);
//innerwindow.set_allow_resize(true);
//innerwindow.set_fullscreen(true);
clan::DisplayWindowDescription win_desc;
win_desc.set_allow_resize(true);
win_desc.set_title("Main");
win_desc.set_size(clan::Size( 1100, 900 ), false);
DisplayWindow window(win_desc);
//DisplayWindow window("main", 1200, 900, false, true);
//window.maximize();
//DisplayWindow window(innerwindow);
Rect viewport = window.get_viewport();
GraphicContext gc = window.get_gc();
ResourceManager resources;
SceneCache::set(resources, std::shared_ptr<SceneCache>(new AppSceneCache()));
ResourceManager sound_resources = XMLResourceManager::create(XMLResourceDocument("../Resources/resources.xml"));
sound_resources_=&sound_resources;
std::string shader_path = "../Resources/Scene3D";
Scene scene(gc, resources, shader_path);
sceneHolder = &scene;
SceneCamera camera(scene);
scene.set_camera(camera);
scene.set_viewport(gc.get_size());
camera.set_orientation(camera_orientation);
camera.set_position(Vec3f(0.0f, 40.0f, down));
Canvas canvas(window);
image_hp = Image(canvas, "../Resources/Images/heart.png");
image_hp.set_alignment(origin_center);
image_hp.set_scale(0.07, 0.07);
image_coin = Image(canvas, "../Resources/Images/coin.png");
image_coin.set_alignment(origin_center);
image_coin.set_scale(0.3, 0.3);
GUIWindowManagerDirect direct(window, canvas);
GUIManager maingui(direct, "../Resources");
GUIComponent *win_comp = new GUIComponent(&maingui, win_desc, "");
radial_menu = new RadialMenu(win_comp);
radial_menu->func_selected.set(this, &game::on_radial_menu_itemselected);
//GameComponent game_component(viewport, &maingui);
/*Rect toolbar_rect = Rect((viewport.get_width() - 448) / 2, viewport.bottom - 56, (viewport.get_width() - 448) / 2 + 448, viewport.bottom);
Toolbar toolbar(toolbar_rect, &game_component); // GameComponent is the "desktop" that the toolbar sits on, as an owner
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell1.png"), Sprite(canvas, "../Resources/Images/spell1_selected.png"), Sprite(canvas, "../Resources/Images/spell1_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell2.png"), Sprite(canvas, "../Resources/Images/spell2_selected.png"), Sprite(canvas, "../Resources/Images/spell2_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell3.png"), Sprite(canvas, "../Resources/Images/spell3_selected.png"), Sprite(canvas, "../Resources/Images/spell3_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell4.png"), Sprite(canvas, "../Resources/Images/spell4_selected.png"), Sprite(canvas, "../Resources/Images/spell4_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell5.png"), Sprite(canvas, "../Resources/Images/spell5_selected.png"), Sprite(canvas, "../Resources/Images/spell5_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell6.png"), Sprite(canvas, "../Resources/Images/spell6_selected.png"), Sprite(canvas, "../Resources/Images/spell6_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell7.png"), Sprite(canvas, "../Resources/Images/spell7_selected.png"), Sprite(canvas, "../Resources/Images/spell7_clicked.png"));
*/
InputDevice keyboard = window.get_ic().get_keyboard();
InputDevice mouse = window.get_ic().get_mouse();
clan::Font font(canvas, "Tahoma", 30); // The clan prefix is required on linux due to a namespace conflict
SceneModel plane(gc, scene, "plane");
SceneModel box(gc, scene, "box");
SceneModel tower(gc, scene, "tower");
SceneModel gate(gc,scene,"gate");
SceneObject object(scene, plane, Vec3f(0.0f, 0.0f, 0.0f));
object.rotate(180.0f, 0.0f, 0.0f);
scene.show_skybox_stars(false);
/*SceneObject box0(scene, tower, Vec3f(20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box1(scene, tower, Vec3f(-20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box2(scene, tower, Vec3f(0.0f, 5.0f, 20.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box3(scene, tower, Vec3f(0.0f, 5.0f, -20.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject tower[10];*/
SceneObject theGate(scene, gate, Vec3f(-75.0f,5.0f,60.0f), Quaternionf(0.0f,0.0f,0.0f,angle_degrees,order_YXZ));
theGate.set_scale(Vec3f(1.0f,2.0f,2.0f));
std::vector<SceneLight> omni_lights;
for (int i = 0; i < 4; i++)
{
SceneLight omni(scene);
omni.set_type(SceneLight::type_omni);
omni.set_color(Vec3f(0.05f));
omni.set_position(Quaternionf(45.0f, 45.0f + i * 90.0f, 0.0f, angle_degrees, order_YXZ).rotate_vector(Vec3f(0.0f, 0.0f, -100.0f)));
omni.set_attenuation_end(200.0f);
omni.set_ambient_illumination(0.025f);
omni_lights.push_back(omni);
}
SceneLight spot(scene);
spot.set_type(SceneLight::type_spot);
spot.set_orientation(Quaternionf(45.0f, 45.0f, 0.0f, angle_degrees, order_YXZ));
spot.set_position(spot.get_orientation().rotate_vector(Vec3f(-55.0f, 90.0f, -550.0f)));
//spot.set_position(Vec3f(-250, 100, -430));
spot.set_color(Vec3f(1.0f, 1.0f, 0.8f));
spot.set_falloff(45.0f);
spot.set_hotspot(15.0f);
spot.set_attenuation_start(150.0f);
spot.set_attenuation_end(1500.0f);
spot.set_shadow_caster(true);
spot.set_rectangle_shape(false);
//spot.set_ambient_illumination(true);
spot.set_aspect_ratio(1.0f);
/*SceneLight spot(scene);
spot.set_type(SceneLight::type_spot);
spot.set_orientation(Quaternionf(30.0f, 30.0f, 0.0f, angle_degrees, order_YXZ));
spot.set_position(spot.get_orientation().rotate_vector(Vec3f(0.0f, 0.0f, -100.0f)));
spot.set_color(Vec3f(1.0f, 1.0f, 0.8f));
spot.set_falloff(45.0f);
spot.set_hotspot(15.0f);
spot.set_attenuation_start(20.0f);
spot.set_attenuation_end(200.0f);
spot.set_shadow_caster(true);
spot.set_rectangle_shape(false);
spot.set_aspect_ratio(1.0f);*/
/*SceneLight spot2(scene);
spot2.set_type(SceneLight::type_spot);
spot2.set_position(Vec3f(0.0f, 100.0f, 0.0f));
spot2.set_color(Vec3f(1.0f, 1.0f, 1.0f) * 3.0f);
spot2.set_falloff(35.0f);
spot2.set_hotspot(30.0f);
spot2.set_attenuation_start(20.0f);
spot2.set_attenuation_end(130.0f);
spot2.set_shadow_caster(true);
spot2.set_rectangle_shape(false);
spot2.set_ambient_illumination(0.025f);*/
wm.NodeArray[0].setPos(75.0f,1.25f,0.0f);
wm.NodeArray[1].setPos(-60.0f,1.25f,0.0f);
wm.NodeArray[2].setPos(-55.0f,1.25f,-65.0f);
wm.NodeArray[3].setPos(60.0f,1.25f,-60.0f);
wm.NodeArray[4].setPos(55.0f,1.25f,65.0f);
wm.NodeArray[5].setPos(-80.0f,1.25f,60.0f);
Physics3DShape box_shape = Physics3DShape::box(Vec3f(5.0f));
Physics3DShape plane_shape = Physics3DShape::box(Vec3f(75.0f, 1.0f, 75.0f));
Physics3DShape sphere_shape = Physics3DShape::sphere(2.0f);
Physics3DObject phys_plane(physics_world, plane_shape, Vec3f(0.0f, -0.5f, 0.0f));
/*Physics3DObject phys_box0(physics_world, box_shape, Vec3f(20.0f, 5.0f, 0.0f), box0.get_orientation());
Physics3DObject phys_box1(physics_world, box_shape, Vec3f(-20.0f, 5.0f, 0.0f), box1.get_orientation());
Physics3DObject phys_box2(physics_world, box_shape, Vec3f(0.0f, 5.0f, 20.0f), box2.get_orientation());
Physics3DObject phys_box3(physics_world, box_shape, Vec3f(0.0f, 5.0f, -20.0f), box3.get_orientation());
Physics3DObject phys_box[10];*/
Physics3DSweepTest sweep_test(physics_world);
Physics3DRayTest raycast(physics_world);
Slot slot_keyboard_key_down = (window.get_ic().get_keyboard()).sig_key_down() .connect(this,&game::on_key_down);
Slot slot_keyboard_key_up = (window.get_ic().get_keyboard()).sig_key_up() .connect(this,&game::on_key_up);
Slot slot_mouse_moved = (window.get_ic().get_mouse()).sig_pointer_move() .connect(this,&game::on_pointer_move);
Slot slot_mouse_down = (window.get_ic().get_mouse()).sig_key_down() .connect(this,&game::on_pointer_down);
Slot slot_mouse_up = (window.get_ic().get_mouse()).sig_key_up() .connect(this,&game::on_pointer_up);
//________________________________________________________________
// S O U N D S
total_channels=3;
current_channel=1;
SoundBuffer music = SoundBuffer::resource("Music1",sound_resources);
music.set_volume(0.3f);
sound_session1.play();
sound_session2.play();
sound_session3.play();
total_samples = 6;
samples.resize(total_samples);
samples[0] = SoundBuffer::resource("Explosion1",sound_resources);
samples[1] = SoundBuffer::resource("Explosion2",sound_resources);
samples[2] = SoundBuffer::resource("Hurt1",sound_resources);
samples[3] = SoundBuffer::resource("Hurt2",sound_resources);
samples[4] = SoundBuffer::resource("Powerup1",sound_resources);
samples[5] = SoundBuffer::resource("Shoot1",sound_resources);
for(int i = 0; i<total_samples; i++)
{
samples[i].set_volume(0.3f);
}
SoundBuffer_Session music_session = music.prepare();
music_session_ = &music_session;
music_session.set_looping(true);
music_session.play();
is_music_muted = false;
/********Enemies(Jasper)************************/
SceneObject enemyobj[30];
wm.spawnCreeps();
for(int i = 0; i < 30; i ++)
{
enemyobj[i] = SceneObject(scene, box);
enemyobj[i].set_scale(Vec3f(0.25f));
wm.enemyArray[i].setEnemyObject(&enemyobj[i]);
}
/***************************************/
ElapsedTimer elapsed_timer;
while (!quit)
{
float time_elapsed = elapsed_timer.seconds_elapsed();
/*spot_dir = std::fmod(spot_dir + time_elapsed * 30.0f, 90.0f);
aspect_time = std::fmod(aspect_time + time_elapsed * 0.2f, 2.0f);
spot2.set_aspect_ratio(clamp(aspect_time >= 1.0f ? 2.0f - aspect_time : aspect_time, 0.1f, 1.0f));
spot2.set_orientation(Quaternionf(65.0f + (spot_dir >= 45.0f ? 90.0f - spot_dir : spot_dir), 60.0f, dir * 4.0f, angle_degrees, order_YXZ));
*/
// Draw with the canvas:
/*canvas.clear(Colorf::cadetblue);
canvas.draw_line(0, 110, 640, 110, Colorf::yellow);
font.draw_text(canvas, 100, 100, "Hello World!", Colorf::lightseagreen);
// Draw any remaining queued-up drawing commands oQAn canvas:
canvas.flush();*/
if (!endgame)
{
if (mouse.get_x() <= 0 && !cameraRestricted)
{
mouse.set_position(0, mouse.get_y());
camera.set_position(camera.get_position()+Vec3f(-mouse_move_speed, 0.0f, 0.0f));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "x=0", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouse.get_y() <= 0 && !cameraRestricted)
{
mouse.set_position(mouse.get_x(), 0);
camera.set_position(camera.get_position()+Vec3f(0.0f, 0.0f, mouse_move_speed));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "y=0", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouse.get_x() >= window.get_gc().get_width()-1 && !cameraRestricted)
{
mouse.set_position(window.get_gc().get_width()-1, mouse.get_y());
camera.set_position(camera.get_position()+Vec3f(mouse_move_speed, 0.0f, 0.0f));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "x=windowRight", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouse.get_y() >= window.get_gc().get_height()-1 && !cameraRestricted)
{
mouse.set_position(mouse.get_x(), window.get_gc().get_height()-1);
camera.set_position(camera.get_position()+Vec3f(0.0f, 0.0f, -mouse_move_speed));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "y=windowBottom", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouseUp)
{
if (selected_tower == "Tower 1")
{
towr.set_type(towr.t_bullet);
cost = 10;
}
else if (selected_tower == "Tower 2")
{
towr.set_type(towr.t_energy);
cost = 15;
}
else if (selected_tower == "Tower 3")
{
towr.set_type(towr.t_rocket);
cost = 20;
}
scene.unproject(mouse_pos, start, end);
end *= 151;
test = start + end;
if (raycast.test(start, test))
{
if (towerCount < 10 && money >= cost)
{
towr.set_pos(Vec3f(raycast.get_hit_position().x, 5.0f, raycast.get_hit_position().z));
towr.create(scene, tower, physics_world);
money -= cost;
towerCount++;
cost = 0;
}
}
mouseUp = false;
//float x = mouse.get_x() - scene.world_to_projection().get_origin_x();
//tower[0] = SceneObject(scene, box, Vec3f(camera.get_position().x, 5.0f, camera.get_position().z));
//tower[0].set_position(Vec3f(0.0f, 5.0f, 0.0f));
//window.flip();
//canvas.clear(Colorf::cadetblue);
/*canvas.draw_line(0, 110, 640, 110, Colorf::yellow);
font.draw_text(canvas, 100, 100, "Hello World!", Colorf::lightseagreen);
// Draw any remaining queued-up drawing commands oQAn canvas:
canvas.flush();
// Present the frame buffer content to the user:
window.flip();*/
}
if (mouse.get_keycode(0))
{
//maingui.process_messages(0);
//test.update();
//show_radial_menu(mouse.get_position());
}
/*if (mouse.get_keycode(1))
{
scene.unproject(mouse.get_position(), start, end);
end *= 151;
Vec3f test = start + end;
if (raycast.test(start, test))
{
Physics3DObject hit = raycast.get_hit_object();
font.draw_text(canvas, 400, 100, "hit", Colorf::lightseagreen);
//hit.set_position(Vec3f(0.0f, -10.0f, 0.0f));
std::stringstream ss3 (std::stringstream::in | std::stringstream::out);
ss3 << hit.get_position().y;
txt3 = ss3.str();
font.draw_text(canvas, 550, 100, txt3, Colorf::lightseagreen);
}
//projectile.set_pos(Vec3f(raycast.get_hit_position().x, 5.0f, raycast.get_hit_position().z));
//projectile.fire(scene, box, physics_world);
//canvas.clear(Colorf::white);
//window.flip();
}*/
if (keyboard.get_keycode(keycode_control))
{
if (window.is_fullscreen())
{
//innerwindow.set_fullscreen(false);
window.set_size(640, 480, true);
window.restore();
}
else
window.set_size(640, 480, false);
}
if (camera.get_position().x <= left)
{
camera.set_position(Vec3f(left, camera.get_position().y, camera.get_position().z));
}
if (camera.get_position().x >= right)
{
camera.set_position(Vec3f(right, camera.get_position().y, camera.get_position().z));
}
if (camera.get_position().z >= top)
{
camera.set_position(Vec3f(camera.get_position().x, camera.get_position().y, top));
}
if (camera.get_position().z <= down)
{
camera.set_position(Vec3f(camera.get_position().x, camera.get_position().y, down));
}
/*if(objects_for_deletion.size()>0)
{
std::list<Gameobject *>::iterator it;
for(it=objects_for_deletion.begin(); it!= objects_for_deletion.end(); ++it)
{
delete (*it);
//towerCount--;
}
objects_for_deletion.clear();
}*/
if(towerObjects.size()>0)
{
std::vector<Gameobject *>::iterator it;
int counter = 0;
for(it=towerObjects.begin(); it!= towerObjects.end(); ++it)
{
towerObjects.at(counter)->update(time_elapsed, wm.enemyArray, 30);
counter++;
}
}
if(missileObjects.size()>0)
{
std::list<Gameobject *>::iterator it;
for(it=missileObjects.begin(); it!= missileObjects.end();)
{
//if (!(*it)->checkActive())
(*it)->update(time_elapsed, wm.enemyArray);
if ((*it)->checkActive())
{
delete(*it);
it = missileObjects.erase(it);
}
else
it++;
}
}
/*******Enemies(Updates)************************/
wm.Update(1);
//time_lasttime = time_elapsed;
if(wm.life > 0)
{
// Put a screen here
life -= wm.life;
wm.life = 0;
}
if (wm.currLevel == 3)
{
endgame = true;
}
/***********************************************/
//scene.update(gc, time_elapsed);
txt3 = ":";
ss3.str("");
ss3.clear();
ss3 << money;
txt3 += ss3.str();
font.draw_text(canvas, 550, 50, txt3, Colorf::lightseagreen);
if (life < 0)
{
endgame = true;
}
scene.render(gc);
/*canvas.clear(clan::Colorf(0.0f,0.0f,0.0f));
std::stringstream ss (std::stringstream::in | std::stringstream::out);
ss << game_time.get_time_elapsed();
std::string troll = ss.str();
font.draw_text(canvas, 100, 100, troll, Colorf::lightseagreen);*/
//canvas.clear(clan::Colorf(0.0f,0.0f,0.0f));
std::stringstream ss (std::stringstream::in | std::stringstream::out);
ss << scene.world_to_projection().get_origin_x();
txt = ss.str();
txt2 = ":";
ss2.str("");
ss2.clear();
ss2 << life;
txt2 += ss2.str();
font.draw_text(canvas, 150, 50, txt2, Colorf::lightseagreen);
//maingui.process_messages(0);
/*font.draw_text(canvas, 0, 100, main, Colorf::lightseagreen);
font.draw_text(canvas, 150, 100, txt, Colorf::lightseagreen);
font.draw_text(canvas, 250, 100, txt2, Colorf::lightseagreen);
canvas.draw_line(0, 110, 640, 110, Colorf::yellow);*/
maingui.render_windows();
image_hp.draw(canvas, 100, 45);
image_coin.draw(canvas, 500, 45);
window.flip();
// Read messages from the windowing system message queue, if any are available:
KeepAlive::process();
}
else
{
//maingui.render_windows();
canvas.clear(Colorf::black);
font.draw_text(canvas, 450, 400, txt4, Colorf::lightseagreen);
window.flip();
// Read messages from the windowing system message queue, if any are available:
KeepAlive::process();
}
}
}
int
main(int argc, char *argv[])
{
const int KERNEL_NPROC = 64;
const int CHILD_STARTUP_SLEEP = 100;
const int MIN_UPTIME = 1000;
if(argc!=2) {
printf(1, "%s", "USAGE: graphs.c <int testnum>\n");
exit();
}
int option = atoi(argv[1]);
if(option == 0) {
//SAME PERCENT RESERVE
//Make this reserve 50
int returnval = reserve(50);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test 4 reserve procs with 50% reserve
//Expect ~same number of times chosen
const int NUM_PROC = 3;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
returnval = reserve(50);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
break;
}
else {
//parent
pids[i+1] = pid;
}
}
if(pid == 0) {
sleep(CHILD_STARTUP_SLEEP*2);
while(1) {
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i] || getpid() == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}
/*else if(option == 2) {
//DIFF BID SPOT
//Make this spot with bid 50
int returnval;
returnval = spot(50);
if(returnval < 0) {
printf(1, "ERROR: spot failed\n");
}
//Expect significant difference in number of times chosen between bid levels
const int NUM_PROC = 10;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
int bid = 20;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
returnval = spot(bid);
if(returnval < 0) {
printf(1, "ERROR: spot failed\n");
}
break;
}
else {
//parent
if(i==4) {
bid+=10;
}
pids[i+1] = pid;
}
}
if(pid == 0) {
sleep(CHILD_STARTUP_SLEEP);
while(1) {
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
printf(1, "getpinfo failed\n");
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}
else if(option == 3) {
//DIFF PERCENT RESERVE
//Make this reserve with 10 percent
int returnval;
returnval = reserve(10);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test different reservation sizes
//Sizes are 10 (parent proc), 20, 30, 40, 50, 50
const int NUM_PROC = 5;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
int percent = 20;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
returnval = reserve(percent);
if(returnval < 0) {
printf(1, "ERROR: spot failed\n");
}
break;
}
else {
//parent
if(i<NUM_PROC-2) {
percent+=10;
}
pids[i+1] = pid;
}
}
if(pid == 0) {
sleep(CHILD_STARTUP_SLEEP);
while(1){
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
//Find pid in pstat
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}*/
/*else if(option == 4) {
//RESERVE CALL TOO LOW
//Test user attempting to reserve a percentage < 0
//Expect -1 to be returned from the reserve call
int flag = reserve(-1);
if(flag < 0) {
printf(1, "Test succeeded, reserve call failed.\n");
}
else {
printf(1, "ERROR: test failed. Reserve call did not fail when percentage < 0 was input.");
}
exit();
}
else if(option == 5) {
//RESERVE CALL TOO HIGH
//Test user attempting to reserve a percentage > 100
//Expect -1 to be returned from the reserve call
int flag = reserve(101);
if(flag < 0) {
printf(1, "Test succeeded, reserve call failed.\n");
}
else {
printf(1, "ERROR: test failed. Reserve call did not fail when a percantage > 100 was input.");
}
exit();
}
else if(option == 6) {
//RESERVE SUM TOO HIGH
//Make this reserve of 100
int returnval = reserve(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test user attempting to reserve too much cpu (currentreservation + newreservation > 200)
//Expect -1 to be returned from second child's reserve call
const int NUM_PROC = 2;
int pids[NUM_PROC];
int i;
int pid;
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
int flag = reserve(100);
if(i==0 && flag < 0) {
printf(1, "ERROR: incorrect reserve failed\n");
}
if(i==1 && flag < 0) {
printf(1, "Test succeeded, reserve call failed.\n");
}
else if(i==1) {
printf(1, "ERROR: test failed. Reserve call did not fail when the total process percent exceeded 200.");
}
break;
}
else {
pids[i] = pid;
sleep(100);
}
}
if(pid == 0) {
while(1);
}
else {
sleep(500);
for(i=0; i<NUM_PROC; i++) {
kill(pids[i]);
wait();
}
exit();
}
}*/
else if(option == 7) {
//CHARGE TEST
//Make this reserve with 100
int returnval = reserve(100);
if(returnval < 0) {
printf(1,"ERROR: spot call failed\n");
}
//Test charge in dollars
//Expecting time*bid/nanodollars = charge
//NOTE: ADD 10 to time and 1 to chosen to insure no error
struct pstat p;
struct pstat *stats = &p;
//returnval = getpinfo(stats);
int prevchosen = 0;
int prevtime = 0;
int i;
int pid = fork();
if(pid == 0) {
returnval = spot(100);
if(returnval < 0) {
printf(1,"ERROR: reserve call failed\n");
}
while(1) {
}
}
sleep(MIN_UPTIME);
returnval = getpinfo(stats);
if(returnval >= 0) {
for(i=0; i<KERNEL_NPROC; i++) {
if(pid == stats->pid[i]) {
printf(1, "%d,%d,%d,%d\n", stats->pid[i], stats->chosen[i]-prevchosen, stats->time[i]-prevtime, stats->charge[i]);
}
}
}
else {
printf(1, "ERROR: getpinfo failed\n");
}
while(1);
}
else if(option == 9) {
//STARVATION TEST EXTRA CREDIT
int returnval = reserve(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
//Test starvation
//Expect ~same number of times chosen
const int NUM_PROC = 4;
int pids[NUM_PROC+1];
int chosen[NUM_PROC+1];
int time[NUM_PROC+1];
int charge[NUM_PROC+1];
int i;
int pid;
pids[0] = getpid();
for(i=0; i<NUM_PROC; i++) {
pid = fork();
if(pid == 0) {
//child
if(i==0) {
returnval = reserve(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
}
else {
returnval = spot(100);
if(returnval < 0) {
printf(1, "ERROR: reserve failed\n");
}
}
break;
}
else {
//parent
if(i==0) {
sleep(20);
}
pids[i+1] = pid;
}
}
if(pid == 0) {
while(1) {
}
}
else {
while(1) {
sleep(MIN_UPTIME);
struct pstat p;
struct pstat *stats = &p;
int returnval = getpinfo(stats);
if(returnval < 0) {
continue;
}
int count = 0;
for(i=0; i<KERNEL_NPROC; i++) {
int j;
for(j=0; j<NUM_PROC+1; j++) {
if(pids[j] == stats->pid[i] || getpid() == stats->pid[i]) {
chosen[j] = stats->chosen[i];
time[j] = stats->time[i];
charge[j] = stats->charge[i];
count++;
}
}
}
for(i=0; i<NUM_PROC+1; i++) {
//pid,chosen,time,charge
printf(1, "%d,%d,%d,%d\n", pids[i], chosen[i], time[i], charge[i]);
}
}
}
}
return 0;
}
RcppExport SEXP AsianOption(SEXP optionParameters){
try{
Rcpp::List rparam(optionParameters);
std::string avgType = Rcpp::as<std::string>(rparam["averageType"]);
std::string type = Rcpp::as<std::string>(rparam["type"]);
double underlying = Rcpp::as<double>(rparam["underlying"]);
double strike = Rcpp::as<double>(rparam["strike"]);
QuantLib::Spread dividendYield = Rcpp::as<double>(rparam["dividendYield"]);
QuantLib::Rate riskFreeRate = Rcpp::as<double>(rparam["riskFreeRate"]);
QuantLib::Time maturity = Rcpp::as<double>(rparam["maturity"]);
// int length = int(maturity*360 + 0.5); // FIXME: this could be better
double volatility = Rcpp::as<double>(rparam["volatility"]);
QuantLib::Option::Type optionType = getOptionType(type);
//from test-suite/asionoptions.cpp
QuantLib::DayCounter dc = QuantLib::Actual360();
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new
QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType,strike));
QuantLib::Average::Type averageType = QuantLib::Average::Geometric;
Rcpp::List rl = R_NilValue;
if (avgType=="geometric"){
averageType = QuantLib::Average::Geometric;
boost::shared_ptr<QuantLib::PricingEngine>
engine(new
QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine(stochProcess));
QuantLib::Date exDate = today + int(maturity * 360 + 0.5);
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
QuantLib::ContinuousAveragingAsianOption option(averageType, payoff, exercise);
option.setPricingEngine(engine);
rl = Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = option.vega(),
Rcpp::Named("theta") = option.theta(),
Rcpp::Named("rho") = option.rho(),
Rcpp::Named("divRho") = option.dividendRho(),
Rcpp::Named("parameters") = optionParameters);
} else if (avgType=="arithmetic"){
averageType = QuantLib::Average::Arithmetic;
boost::shared_ptr<QuantLib::PricingEngine> engine =
QuantLib::MakeMCDiscreteArithmeticAPEngine<QuantLib::LowDiscrepancy>(stochProcess)
.withSamples(2047)
.withControlVariate();
//boost::shared_ptr<PricingEngine> engine =
// MakeMCDiscreteArithmeticASEngine<LowDiscrepancy>(stochProcess)
// .withSeed(3456789)
// .withSamples(1023);
QuantLib::Size fixings = Rcpp::as<double>(rparam["fixings"]);
QuantLib::Time length = Rcpp::as<double>(rparam["length"]);
QuantLib::Time first = Rcpp::as<double>(rparam["first"]);
QuantLib::Time dt = length / (fixings - 1);
std::vector<QuantLib::Time> timeIncrements(fixings);
std::vector<QuantLib::Date> fixingDates(fixings);
timeIncrements[0] = first;
fixingDates[0] = today + QuantLib::Integer(timeIncrements[0] * 360 + 0.5);
for (QuantLib::Size i=1; i<fixings; i++) {
timeIncrements[i] = i*dt + first;
fixingDates[i] = today + QuantLib::Integer(timeIncrements[i]*360+0.5);
}
QuantLib::Real runningSum = 0.0;
QuantLib::Size pastFixing = 0;
boost::shared_ptr<QuantLib::Exercise>
exercise(new QuantLib::EuropeanExercise(fixingDates[fixings-1]));
QuantLib::DiscreteAveragingAsianOption option(QuantLib::Average::Arithmetic,
runningSum,
pastFixing,
fixingDates,
payoff,
exercise);
option.setPricingEngine(engine);
rl = Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = R_NaN,
Rcpp::Named("gamma") = R_NaN,
Rcpp::Named("vega") = R_NaN,
Rcpp::Named("theta") = R_NaN,
Rcpp::Named("rho") = R_NaN,
Rcpp::Named("divRho") = R_NaN,
Rcpp::Named("parameters") = optionParameters);
} else {
throw std::range_error("Unknown average type " + type);
}
return rl;
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
void AnalyticCompoundOptionEngine::calculate() const {
QL_REQUIRE(strikeDaughter()>0.0,
"Daughter strike must be positive");
QL_REQUIRE(strikeMother()>0.0,
"Mother strike must be positive");
QL_REQUIRE(spot() >= 0.0, "negative or null underlying given");
/* Solver Setup ***************************************************/
Date helpDate(process_->riskFreeRate()->referenceDate());
Date helpMaturity=helpDate+(maturityDaughter()-maturityMother())*Days;
Real vol =process_->blackVolatility()->blackVol(helpMaturity,
strikeDaughter());
Time helpTimeToMat=process_->time(helpMaturity);
vol=vol*std::sqrt(helpTimeToMat);
DiscountFactor dividendDiscount =
process_->dividendYield()->discount(helpMaturity);
DiscountFactor riskFreeDiscount =
process_->riskFreeRate()->discount(helpMaturity);
boost::shared_ptr<ImpliedSpotHelper> f(
new ImpliedSpotHelper(dividendDiscount, riskFreeDiscount,
vol, payoffDaughter(), strikeMother()));
Brent solver;
solver.setMaxEvaluations(1000);
Real accuracy = 1.0e-6;
Real X=0.0;
Real sSolved=0.0;
sSolved=solver.solve(*f, accuracy, strikeDaughter(), 1.0e-6, strikeDaughter()*1000.0);
X=transformX(sSolved); // transform stock to return as in Wystup's book
/* Solver Setup Finished*****************************************/
Real phi=typeDaughter(); // -1 or 1
Real w=typeMother(); // -1 or 1
Real rho=std::sqrt(residualTimeMother()/residualTimeDaughter());
BivariateCumulativeNormalDistributionDr78 N2(w*rho) ;
DiscountFactor ddD=dividendDiscountDaughter();
DiscountFactor rdD=riskFreeDiscountDaughter();
//DiscountFactor ddM=dividendDiscountMother();
DiscountFactor rdM=riskFreeDiscountMother();
Real XmSM=X-stdDeviationMother();
Real S=spot();
Real dP=dPlus();
Real dPT12=dPlusTau12(sSolved);
Real vD=volatilityDaughter();
Real dM=dMinus();
Real strD=strikeDaughter();
Real strM=strikeMother();
Real rTM=residualTimeMother();
Real rTD=residualTimeDaughter();
Real rD=riskFreeRateDaughter();
Real dD=dividendRateDaughter();
Real tempRes=0.0;
Real tempDelta=0.0;
Real tempGamma=0.0;
Real tempVega=0.0;
Real tempTheta=0.0;
Real N2XmSM=N2(-phi*w*XmSM,phi*dP);
Real N2X=N2(-phi*w*X,phi*dM);
Real NeX=N_(-phi*w*e(X));
Real NX=N_(-phi*w*X);
Real NT12=N_(phi*dPT12);
Real ndP=n_(dP);
Real nXm=n_(XmSM);
Real invMTime=1/std::sqrt(rTM);
Real invDTime=1/std::sqrt(rTD);
tempRes=phi*w*S*ddD*N2XmSM-phi*w*strD*rdD*N2X-w*strM*rdM*NX;
tempDelta=phi*w*ddD*N2XmSM;
tempGamma=(ddD/(vD*S))*(invMTime*nXm*NT12+w*invDTime*ndP*NeX);
tempVega=ddD*S*((1/invMTime)*nXm*NT12+w*(1/invDTime)*ndP*NeX);
tempTheta+=phi*w*dD*S*ddD*N2XmSM-phi*w*rD*strD*rdD*N2X-w*rD*strM*rdM*NX;
tempTheta-=0.5*vD*S*ddD*(invMTime*nXm*NT12+w*invDTime*ndP*NeX);
results_.value=tempRes;
results_.delta=tempDelta;
results_.gamma=tempGamma;
results_.vega=tempVega;
results_.theta=tempTheta;
}
GLight::GLight(const Any& any) {
any.verifyName("GLight");
if (any.type() == Any::TABLE) {
*this = GLight();
Vector3 spotTarget;
bool hasSpotTarget = false;
for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) {
const std::string& key = toLower(it->key);
if (key == "position") {
position = it->value;
} else if (key == "rightdirection") {
rightDirection = it->value;
} else if (key == "spotdirection") {
spotDirection = Vector3(it->value).directionOrZero();
} else if (key == "spottarget") {
spotTarget = it->value;
hasSpotTarget = true;
} else if (key == "spotcutoff") {
spotCutoff = it->value.number();
} else if (key == "spotsquare") {
spotSquare = it->value.boolean();
} else if (key == "attenuation") {
attenuation[0] = it->value[0].number();
attenuation[1] = it->value[1].number();
attenuation[2] = it->value[2].number();
} else if (key == "color") {
color = it->value;
} else if (key == "enabled") {
enabled = it->value.boolean();
} else if (key == "specular") {
specular = it->value.boolean();
} else if (key == "diffuse") {
diffuse = it->value.boolean();
} else {
any.verify(false, "Illegal key: " + it->key);
}
}
if (hasSpotTarget) {
spotDirection = (spotTarget - position.xyz()).direction();
}
} else if (toLower(any.name()) == "glight::directional") {
*this = directional(any[0], any[1],
(any.size() > 2) ? any[2] : Any(true),
(any.size() > 3) ? any[3] : Any(true));
} else if (toLower(any.name()) == "glight::point") {
*this = point(any[0], any[1],
(any.size() > 2) ? any[2] : Any(1),
(any.size() > 3) ? any[3] : Any(0),
(any.size() > 4) ? any[4] : Any(0.5f),
(any.size() > 5) ? any[5] : Any(true),
(any.size() > 6) ? any[6] : Any(true));
} else if (toLower(any.name()) == "glight::spot") {
*this = spot(any[0], any[1], any[2], any[3],
(any.size() > 4) ? any[4] : Any(1),
(any.size() > 5) ? any[5] : Any(0),
(any.size() > 6) ? any[6] : Any(0),
(any.size() > 7) ? any[7] : Any(true),
(any.size() > 8) ? any[8] : Any(true));
} else {
any.verify(false, "Unrecognized name");
}
}
void spread(void)
{
float min_cost;
int ros_max, ros_base, dir;
int row, col;
int cell_count = 0, ncells = 0;
struct cell_ptrHa *to_cell, *old_to_cell;
struct costHa *pres_cell;
/* initialize using arbitrary value, this value is never used except for debug */
min_cost = 0;
ncells = nrows * ncols;
G_message
("Finding spread time - number of cells visited in percentage ... %3d%%",
0);
pres_cell = (struct costHa *)G_malloc(sizeof(struct costHa));
get_minHa(heap, pres_cell, heap_len);
G_debug(2, "begin spread: cost(%d,%d)=%f", pres_cell->row, pres_cell->col,
pres_cell->min_cost);
G_debug(2,
" heap_len=%ld pres_cell->min_cost=%f time_lag=%d",
heap_len, pres_cell->min_cost, time_lag);
while (heap_len-- > 0 && pres_cell->min_cost < init_time + time_lag + 1.0) {
ros_max = DATA(map_max, pres_cell->row, pres_cell->col);
ros_base = DATA(map_base, pres_cell->row, pres_cell->col);
dir = DATA(map_dir, pres_cell->row, pres_cell->col);
/*Select end cells of links of the present cell */
select_linksB(pres_cell, least / 2, comp_dens);
#ifdef DEBUG
to_cell = front_cell;
while (to_cell != NULL) {
printf("(%d,%d) ", to_cell->row, to_cell->col);
to_cell = to_cell->next;
}
#endif
/*Get a cell in the list each time, and compute culmulative costs
*via the current spread cell*/
to_cell = front_cell;
while (to_cell != NULL) {
/*calculate cumulative costs,
*function returns -1 if detected a barrier */
if (cumulative
(pres_cell, to_cell, ros_max, ros_base, dir,
&min_cost) == -1) {
old_to_cell = to_cell;
to_cell = to_cell->next;
front_cell = to_cell;
G_free(old_to_cell);
continue;
}
G_debug(2, " finish a link: cost(%d,%d)->(%d,%d)=%f",
pres_cell->row, pres_cell->col, to_cell->row,
to_cell->col, min_cost);
/*update the cumulative time/cost */
update(pres_cell, to_cell->row, to_cell->col, to_cell->angle,
min_cost);
old_to_cell = to_cell;
to_cell = to_cell->next;
front_cell = to_cell;
G_free(old_to_cell);
}
/*compute spotting fires */
if (spotting)
spot(pres_cell, dir);
/*mark a visited cell */
DATA(map_visit, pres_cell->row, pres_cell->col) = YES;
#if 0
if (display)
draw_a_cell(pres_cell->row, pres_cell->col,
(int)pres_cell->min_cost);
#endif
cell_count++;
if ((100 * cell_count / ncells) % 2 == 0 &&
(100 * (cell_count + (int)(0.009 * ncells)) / ncells) % 2 == 0) {
G_percent(cell_count, ncells, 2);
}
get_minHa(heap, pres_cell, heap_len);
G_debug(2,
"in while: heap_len=%ld pres_cell->min_cost=%f time_lag=%d",
heap_len, pres_cell->min_cost, time_lag);
} /*end 'while (heap_len-- >0)' */
G_free(pres_cell);
/*Assign min_cost values to un-reached area */
for (row = 0; row < nrows; row++) {
for (col = 0; col < ncols; col++) {
if (!DATA(map_visit, row, col)) {
DATA(map_out, row, col) = (float)BARRIER;
if (x_out)
DATA(map_x_out, row, col) = 0;
if (y_out)
DATA(map_y_out, row, col) = 0;
}
}
}
G_debug(2, "end spread");
} /*end spread () */
Real AnalyticCompoundOptionEngine::dPlus() const{
Real forward = spot() * dividendDiscountDaughter() / riskFreeDiscountDaughter();
Real sd=stdDeviationDaughter();
return std::log(forward/strikeDaughter())/sd+0.5*sd;
}
// [[Rcpp::export]]
Rcpp::List europeanOptionEngine(std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividends,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividendsTimeUntil) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Option::Type optionType = getOptionType(type);
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
// new framework as per QuantLib 0.3.5
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote( underlying ));
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote( volatility ));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote( dividendYield ));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote( riskFreeRate ));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today, rRate, dc);
bool withDividends = discreteDividends.isNotNull() && discreteDividendsTimeUntil.isNotNull();
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
if (withDividends) {
Rcpp::NumericVector divvalues(discreteDividends), divtimes(discreteDividendsTimeUntil);
int n = divvalues.size();
std::vector<QuantLib::Date> discDivDates(n);
std::vector<double> discDividends(n);
for (int i = 0; i < n; i++) {
#ifdef QL_HIGH_RESOLUTION_DATE
boost::posix_time::time_duration discreteDividendLength = boost::posix_time::minutes(boost::uint64_t(divtimes[i] * 360 * 24 * 60));
discDivDates[i] = QuantLib::Date(today.dateTime() + discreteDividendLength);
#else
discDivDates[i] = today + int(divtimes[i] * 360 + 0.5);
#endif
discDividends[i] = divvalues[i];
}
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::AnalyticDividendEuropeanEngine(stochProcess));
QuantLib::DividendVanillaOption option(payoff, exercise, discDivDates, discDividends);
option.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = option.vega(),
Rcpp::Named("theta") = option.theta(),
Rcpp::Named("rho") = option.rho(),
Rcpp::Named("divRho") = R_NaReal);
}
else {
boost::shared_ptr<QuantLib::VanillaOption> option = makeOption(payoff, exercise, spot, qTS, rTS, volTS);
return Rcpp::List::create(Rcpp::Named("value") = option->NPV(),
Rcpp::Named("delta") = option->delta(),
Rcpp::Named("gamma") = option->gamma(),
Rcpp::Named("vega") = option->vega(),
Rcpp::Named("theta") = option->theta(),
Rcpp::Named("rho") = option->rho(),
Rcpp::Named("divRho") = option->dividendRho());
}
}
// [[Rcpp::export]]
Rcpp::List americanOptionEngine(std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
int timeSteps,
int gridPoints,
std::string engine,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividends,
Rcpp::Nullable<Rcpp::NumericVector> discreteDividendsTimeUntil) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity * 360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Option::Type optionType = getOptionType(type);
// new framework as per QuantLib 0.3.5, updated for 0.3.7
// updated again for 0.9.0, see eg test-suite/americanoption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today,qRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today,rRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
bool withDividends = discreteDividends.isNotNull() && discreteDividendsTimeUntil.isNotNull();
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::AmericanExercise(today, exDate));
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
if (withDividends) {
Rcpp::NumericVector divvalues(discreteDividends), divtimes(discreteDividendsTimeUntil);
int n = divvalues.size();
std::vector<QuantLib::Date> discDivDates(n);
std::vector<double> discDividends(n);
for (int i = 0; i < n; i++) {
#ifdef QL_HIGH_RESOLUTION_DATE
boost::posix_time::time_duration discreteDividendLength = boost::posix_time::minutes(boost::uint64_t(divtimes[i] * 360 * 24 * 60));
discDivDates[i] = QuantLib::Date(today.dateTime() + discreteDividendLength);
#else
discDivDates[i] = today + int(divtimes[i] * 360 + 0.5);
#endif
discDividends[i] = divvalues[i];
}
QuantLib::DividendVanillaOption option(payoff, exercise, discDivDates, discDividends);
if (engine=="BaroneAdesiWhaley") {
Rcpp::warning("Discrete dividends, engine switched to CrankNicolson");
engine = "CrankNicolson";
}
if (engine=="CrankNicolson") { // FDDividendAmericanEngine only works with CrankNicolson
// suggestion by Bryan Lewis: use CrankNicolson for greeks
boost::shared_ptr<QuantLib::PricingEngine>
fdcnengine(new QuantLib::FDDividendAmericanEngine<QuantLib::CrankNicolson>(stochProcess, timeSteps, gridPoints));
option.setPricingEngine(fdcnengine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
} else {
throw std::range_error("Unknown engine " + engine);
}
} else {
QuantLib::VanillaOption option(payoff, exercise);
if (engine=="BaroneAdesiWhaley") {
// new from 0.3.7 BaroneAdesiWhaley
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::BaroneAdesiWhaleyApproximationEngine(stochProcess));
option.setPricingEngine(engine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = R_NaReal,
Rcpp::Named("gamma") = R_NaReal,
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
} else if (engine=="CrankNicolson") {
// suggestion by Bryan Lewis: use CrankNicolson for greeks
boost::shared_ptr<QuantLib::PricingEngine>
fdcnengine(new QuantLib::FDAmericanEngine<QuantLib::CrankNicolson>(stochProcess, timeSteps, gridPoints));
option.setPricingEngine(fdcnengine);
return Rcpp::List::create(Rcpp::Named("value") = option.NPV(),
Rcpp::Named("delta") = option.delta(),
Rcpp::Named("gamma") = option.gamma(),
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
} else {
throw std::range_error("Unknown engine " + engine);
}
}
}
// [[Rcpp::export]]
Rcpp::List binaryOptionEngine(std::string binType,
std::string type,
std::string excType,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double cashPayoff) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better, but same rounding in QL
#endif
QuantLib::Option::Type optionType = getOptionType(type);
// new QuantLib 0.3.5 framework: digitals, updated for 0.3.7
// updated again for QuantLib 0.9.0,
// cf QuantLib-0.9.0/test-suite/digitaloption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today,qRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today,rRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff;
if (binType=="cash") {
boost::shared_ptr<QuantLib::StrikedTypePayoff> con(new QuantLib::CashOrNothingPayoff(optionType, strike, cashPayoff));
payoff = con;
} else if (binType=="asset") {
boost::shared_ptr<QuantLib::StrikedTypePayoff> aon(new QuantLib::AssetOrNothingPayoff(optionType, strike));
payoff = aon;
} else if (binType=="gap") {
boost::shared_ptr<QuantLib::StrikedTypePayoff> gap(new QuantLib::GapPayoff(optionType, strike, cashPayoff));
payoff = gap;
} else {
throw std::range_error("Unknown binary option type " + binType);
}
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise;
if (excType=="american") {
boost::shared_ptr<QuantLib::Exercise> amEx(new QuantLib::AmericanExercise(today, exDate));
exercise = amEx;
} else if (excType=="european") {
boost::shared_ptr<QuantLib::Exercise> euEx(new QuantLib::EuropeanExercise(exDate));
exercise = euEx;
} else {
throw std::range_error("Unknown binary exercise type " + excType);
}
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
boost::shared_ptr<QuantLib::PricingEngine> engine;
if (excType=="american") {
boost::shared_ptr<QuantLib::PricingEngine> amEng(new QuantLib::AnalyticDigitalAmericanEngine(stochProcess));
engine = amEng;
} else if (excType=="european") {
boost::shared_ptr<QuantLib::PricingEngine> euEng(new QuantLib::AnalyticEuropeanEngine(stochProcess));
engine = euEng;
} else {
throw std::range_error("Unknown binary exercise type " + excType);
}
QuantLib::VanillaOption opt(payoff, exercise);
opt.setPricingEngine(engine);
Rcpp::List rl = Rcpp::List::create(Rcpp::Named("value") = opt.NPV(),
Rcpp::Named("delta") = opt.delta(),
Rcpp::Named("gamma") = opt.gamma(),
Rcpp::Named("vega") = (excType=="european") ? opt.vega() : R_NaN,
Rcpp::Named("theta") = (excType=="european") ? opt.theta() : R_NaN,
Rcpp::Named("rho") = (excType=="european") ? opt.rho() : R_NaN,
Rcpp::Named("divRho") = (excType=="european") ? opt.dividendRho() : R_NaN);
return rl;
}
// [[Rcpp::export]]
Rcpp::List barrierOptionEngine(std::string barrType,
std::string type,
double underlying,
double strike,
double dividendYield,
double riskFreeRate,
double maturity,
double volatility,
double barrier,
double rebate) {
#ifdef QL_HIGH_RESOLUTION_DATE
// in minutes
boost::posix_time::time_duration length = boost::posix_time::minutes(boost::uint64_t(maturity * 360 * 24 * 60));
#else
int length = int(maturity*360 + 0.5); // FIXME: this could be better
#endif
QuantLib::Barrier::Type barrierType = QuantLib::Barrier::DownIn;
if (barrType=="downin") {
barrierType = QuantLib::Barrier::DownIn;
} else if (barrType=="upin") {
barrierType = QuantLib::Barrier::UpIn;
} else if (barrType=="downout") {
barrierType = QuantLib::Barrier::DownOut;
} else if (barrType=="upout") {
barrierType = QuantLib::Barrier::UpOut;
} else {
throw std::range_error("Unknown barrier type " + type);
}
QuantLib::Option::Type optionType = getOptionType(type);
// new QuantLib 0.3.5 framework, updated for 0.3.7
// updated again for QuantLib 0.9.0,
// cf QuantLib-0.9.0/test-suite/barrieroption.cpp
QuantLib::Date today = QuantLib::Date::todaysDate();
QuantLib::Settings::instance().evaluationDate() = today;
QuantLib::DayCounter dc = QuantLib::Actual360();
boost::shared_ptr<QuantLib::SimpleQuote> spot(new QuantLib::SimpleQuote(underlying));
boost::shared_ptr<QuantLib::SimpleQuote> qRate(new QuantLib::SimpleQuote(dividendYield));
boost::shared_ptr<QuantLib::YieldTermStructure> qTS = flatRate(today, qRate, dc);
boost::shared_ptr<QuantLib::SimpleQuote> rRate(new QuantLib::SimpleQuote(riskFreeRate));
boost::shared_ptr<QuantLib::YieldTermStructure> rTS = flatRate(today,rRate,dc);
boost::shared_ptr<QuantLib::SimpleQuote> vol(new QuantLib::SimpleQuote(volatility));
boost::shared_ptr<QuantLib::BlackVolTermStructure> volTS = flatVol(today, vol, dc);
#ifdef QL_HIGH_RESOLUTION_DATE
QuantLib::Date exDate(today.dateTime() + length);
#else
QuantLib::Date exDate = today + length;
#endif
boost::shared_ptr<QuantLib::Exercise> exercise(new QuantLib::EuropeanExercise(exDate));
boost::shared_ptr<QuantLib::StrikedTypePayoff> payoff(new QuantLib::PlainVanillaPayoff(optionType, strike));
boost::shared_ptr<QuantLib::BlackScholesMertonProcess>
stochProcess(new QuantLib::BlackScholesMertonProcess(QuantLib::Handle<QuantLib::Quote>(spot),
QuantLib::Handle<QuantLib::YieldTermStructure>(qTS),
QuantLib::Handle<QuantLib::YieldTermStructure>(rTS),
QuantLib::Handle<QuantLib::BlackVolTermStructure>(volTS)));
// Size timeSteps = 1;
// bool antitheticVariate = false;
// bool controlVariate = false;
// Size requiredSamples = 10000;
// double requiredTolerance = 0.02;
// Size maxSamples = 1000000;
// bool isBiased = false;
boost::shared_ptr<QuantLib::PricingEngine> engine(new QuantLib::AnalyticBarrierEngine(stochProcess));
// need to explicitly reference BarrierOption from QuantLib here
QuantLib::BarrierOption barrierOption(barrierType,
barrier,
rebate,
payoff,
exercise);
barrierOption.setPricingEngine(engine);
Rcpp::List rl = Rcpp::List::create(Rcpp::Named("value") = barrierOption.NPV(),
Rcpp::Named("delta") = R_NaReal,
Rcpp::Named("gamma") = R_NaReal,
Rcpp::Named("vega") = R_NaReal,
Rcpp::Named("theta") = R_NaReal,
Rcpp::Named("rho") = R_NaReal,
Rcpp::Named("divRho") = R_NaReal);
return rl;
}
double Stock::price() const{
return spot();
}
