out=1.0,
                                      down=0.0,
                                      points=252)
    ]

    results = []
    for o in options:
        if (platform_name == "GPU"):
            from ForwardFinancialFramework.Platforms.OpenCLGPU import OpenCLGPU_MonteCarlo, OpenCLGPU
            platform = OpenCLGPU.OpenCLGPU()
            mc_solver = OpenCLGPU_MonteCarlo.OpenCLGPU_MonteCarlo([o], paths,
                                                                  platform)

        elif (platform_name == "CPU"):
            from ForwardFinancialFramework.Platforms.MulticoreCPU import MulticoreCPU_MonteCarlo, MulticoreCPU
            platform = MulticoreCPU.MulticoreCPU()
            mc_solver = MulticoreCPU_MonteCarlo.MulticoreCPU_MonteCarlo(
                [o], paths, platform)

        elif (platform_name == "FPGA"):
            from ForwardFinancialFramework.Platforms.MaxelerFPGA import MaxelerFPGA_MonteCarlo, MaxelerFPGA
            platform = MaxelerFPGA.MaxelerFPGA(instances=20)
            mc_solver = MaxelerFPGA_MonteCarlo.MaxelerFPGA_MonteCarlo([o],
                                                                      paths,
                                                                      platform)

        if ("Compile" in platform_arg or platform_name != "FPGA"):
            mc_solver.generate()
            mc_solver.compile()

        if ("Execute" in platform_arg or platform_name != "FPGA"):
Exemplo n.º 2
0
    output_file = open(output_filename, "w")
    for i in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048,
              4096]:  #range(1,2**len(derivative)):
        test_derivative = []
        test_derivative_set = []

        selection = bin(i)[2:]
        index = len(selection) - 1
        for s in selection:
            if (s == "1"):
                test_derivative.append(derivative[index])
                test_derivative_set.append(index + 1)
            index = index - 1

        multicore_platform = MulticoreCPU.MulticoreCPU(threads)

        mc_solver = MulticoreCPU_MonteCarlo.MulticoreCPU_MonteCarlo(
            test_derivative,
            paths,
            multicore_platform,
            reduce_underlyings=True)
        mc_solver.solver_metadata["default_points"] = points
        mc_solver.generate()
        mc_solver.compile()

        results = []
        offset = len(test_derivative) * 2
        CPU_time = 0.0
        Wall_time = 0.0
        efficiency_factor = 0.0
Exemplo n.º 3
0
 volatility_volatility = 0.425
 rho = -0.4644
 kappa = 2.75
 theta = 0.035
 
 #Kaiserslatuarn Option Number 5
 strike_price = 90
 barrier = 80.0
 second_barrier = 120
 out = 1.0
 call = 1.0
 down = 0.0
 
 parameter_set = "I"
 reference_value = 5.7576
 
 #underlying = [Underlying.Underlying(rfir,current_price)]
 #option = [Option.Option(underlying,time_period,call,strike_price)]
 
 underlying = [Heston.Heston(rfir=rfir,current_price=current_price,initial_volatility=initial_volatility,volatility_volatility=volatility_volatility,rho=rho,kappa=kappa,theta=theta)]
 option = [Double_Barrier_Option.Double_Barrier_Option(underlying,call=call,strike_price=strike_price,time_period=time_period,points=points,out=out,barrier=barrier,second_barrier=second_barrier,down=down)]
 option.append(European_Option.European_Option(underlying,call=call,strike_price=strike_price,time_period=time_period))
 
 multicore_cpu_platform = MulticoreCPU.MulticoreCPU()
 
 mc_solver = MulticoreCPU_MonteCarlo.MulticoreCPU_MonteCarlo(option,paths,multicore_cpu_platform)
 mc_solver.generate()
 compile_output = mc_solver.compile()
 execution_output = mc_solver.execute()
 
 print execution_output