A Parallel Firefly Meta-heuristics Algorithm for Financial Option Pricing

A Parallel Firefly Meta-heuristics Algorithm for Financial Option Pricing Kevin Mather

Parimala Thulasiraman

Ruppa K. Thulasiram

Department of Computer Science University of Manitoba Winnipeg, MB, Canada [email protected]

Department of Computer Science University of Manitoba Winnipeg, MB, Canada [email protected]

Department of Computer Science University of Manitoba Winnipeg, MB, Canada [email protected]

Sujata Dash Department of Computer Science University of Manitoba Winnipeg, MB, Canada [email protected] Abstract—In this paper we present a design and development of a parallel Firefly meta-heuristic algorithm for option pricing. We study the parallel algorithm for performance both theoretically and experimentally. Our implementation of the algorithm exhibits significant speedup for financial option pricing problem and demonstrates the utility of our parallel algorithm even when the problem size with large number of Fireflies is deployed. We also present a detailed analysis of the theoretical runtime cost of firefly algorithm on both the RAM and P-RAM models of computation. Moreover, we identify certain issues in the algorithm regarding global memory access pattern, which could be studied for further improvement. Keywords: Swarm Intelligence, Firefly Algorithm, Option Pricing, Parallel computing

I. INTRODUCTION Financial option pricing problem is very complicated, in general, and gets further complicated when dealing with real time data. Quicker results are expected to help in redesign of algorithms for better calibration. High performance computers would help in expediting the computations and faster results. The Black-Scholes-Merton (BSM) model ( [1], [2]) presented an analytical solution to price simple derivatives such as European option using a concept known as risk-neutrality. The binomial model [3] presented a discrete time approach to price options following investor risk-neutrality approach proposed by BSM model. This model brought operational improvement to pricing options without much of the assumptions imposed in BSM model. Hence, with binomial model one could price more complicated options such as American options. Many quantitative techniques (see for example, [4]–[7]) enriched the literature and practical evaluation of derivative instruments. Advances in computing allowed development of heuristic algorithms for real world optimization problems and eventually nature-inspired heuristics were introduced for derivative pricing problem, see for example ( [8], [9]). Heuristics, especially nature-inspired techniques studied for real world applications are not standard. That is, what is best for an application may not work for some other application. When designing parallel algorithm(s), this is more evident as the current study reveals.

978-1-5386-2726-6/17/$31.00 ©2017 IEEE

In other words, it is difficult to determine the heuristic that would work best for pricing options. The rest of this paper is organized as follows: In the following section II we briefly describe the concept of financial option and entailing problem. We classify the solution techniques into three groups (theoretical models, deterministic algorithms and nature-inspired algorithms and briefly review the literature in each group with a parallel computing perspective. In section III we present the firefly meta-heuristic approach. Following this we briefly present ideas from nature-inspired algorithms for financial option pricing in section II-C. A discussion on the parallel implementation of the firefly algorithm is presented in section IV. Section V discusses the results of our firefly algorithm. We present a theoretical analysis on the computational cost of our algorithm in section V-A; and present experimental results in section V-B. In section VI we present a few important concluding remarks. II. FINANCIAL OPTIONS A derivative is a financial instrument whose value depends on, or is derived from, the price of another asset such as stocks. Options and futures are now traded actively in many exchanges. We start with the definitions [4] of call and put options, as well as European style and American style options. A Call (Put) option is a contract that gives the right to its holder (i.e. buyer - the other party is known as writer) without creating an obligation, to buy (sell) a pre-specified underlying asset at a predetermined price; Usually this right is created for a specific time period, e.g. three, six, nine or twelve months. If the option can be exercised only at its expiration (i.e. the underlying asset can be purchased only at the end of the contract) the option is referred to as an European style Call Option (or European Call). If it can be exercised on any date before its maturity, then the option is referred to as an American style Call Option (or American Call). The call option creates an obligation for its writer to fulfill the contract with the buyer. That is, when the option is exercised,

the writer of the option has to sell to (buy from) the holder, the underlying asset at the contract price. Determining an optimum exercise policy is an important issue in pricing American options. The solution for the optimal exercise policy must be performed numerically, and is a computationally intensive problem. To price an American put option we may generate a binary tree for the asset price and then roll backward the tree checking if at each node early exercise is optimal [11]. Many such deterministic algorithms are critically reviewed and summarized in [12]. A. Theoretical Models and Analytical Solutions As mentioned before, a pioneering model for option pricing was designed by Fisher Black, Myron Scholes and Robert Merton in 1973. This BSM model ( [1], [2]) presented an analytical solution to price simple derivatives such as European option using a concept known as risk-neutrality. Assumption of constant volatility in this model was detrimental in capturing the real market results closely. The emergence of GARCH model has provided feasible ways of computing stochastic volatilities [17]. The GARCH model was used to price options in [18]. It was observed [21] that the problem size in lattice based algorithms in GARCH framework [19], [20] grows exponentially when the number of partitions per day, n, exceeds a threshold determined by the GARCH parameters. These studies have not considered the effect of various parameters of the GARCH model on the volatility of underlying asset(s). By fuzzifying some of the GARCH parameters the effect of volatility models on option pricing has been reported in [22] following the work of Duan et al. [23]. B. Deterministic Algorithms for Option Pricing Following the pioneering work in BSM model, many discrete time approaches were developed by researchers, which could be classified into three general categories: tree based, simulation, engineering approaches. Though the details could be found in many published materials (see for example [26], [27]), a glimpse of these approaches is presented in following subsections with focus on parallel algorithms for these approaches. 1) Tree Based Approach: A first discrete-time approach model was proposed by Cox, Ross and Rubinstein in 1979 [3]. This model simulates the price movement for the given period of the option contract as a tree (binomial tree) where the leaf nodes represent the expiration time. Pay-offs are computed at each node of a given time step and marched backward towards to the root node of the tree, representing the current time, discounting at each time for computing the option value. The computed value at the node would represent the option value of the contract and would be used to make decision if investment could be made in the underlying asset. Since the number of time steps would determine the accuracy of the option value computed using the binomial tree, the problem becomes highly computationally intensive and hence would utilize parallel computer architecture(s) in computing the option value. The motivation for high performance computing in finance were

well captured in couple of general articles [28], [29]. A first parallel design and implementation of this binomial tree based algorithm was reported in [11]. The need for high performance computing for option pricing is well explained in this work as well. Many works have been reported in this area of research as evidenced in special issues of journals such as [26], [27], however, emergence of nature-inspired algorithm(s) for option pricing and parallelizing such as algorithm for high performance computing is a new trend and in that sense the current work is a novel attempt. 2) Monte-Carlo Simulation: The price evolution of an underlying asset in a stock can be seen as a random walk and can be simulated for a given contract period of an option. Boyle [31] proposed such a simulation using Monte-Carlo (MC) approach and generated option pricing results close to the analytical solution of BSM model for simple European options. Due to its easy implementation many practitioners use this to get a general idea of option value as a first attempt. Also, since each random walk is different from each other, MC simulation can be implemented in a parallel computing environment very easily. In fact, in parallel computing literature this kind of approaches (algorithms) are called pleasingly parallel algorithm. Accuracy of the results is dictated by the random numbers used in the simulation. Since most of random number generators generate pseudo random numbers, quality of randomness is subjective. To alleviate this problem, few variation of this MC simulation has been proposed in the past such as Quasi MC, which seem to do slightly better job (see for example [32]) when implemented in a distributed computing environment. 3) Engineering Techniques: As mentioned earlier, BSM model is only applicable to find value of an European option. Therefore, focus shifted towards numerical techniques to price options. In 1977, Brennan and Schwartz [6] introduced finitedifferencing model and later in 1979, Cox et al. [3] introduced binomial lattice model to numerically compute the worth of a financial option contract. Convolution approaches such as fast Fourier transform [24], [25] have also been employed for option pricing. These techniques are very efficient, however, getting accurate results from these techniques require intensive computation and takes longer execution time. Effort in parallelizing these algorithms have been reported in the past (see for example [26], [27]). C. Nature-Inspired Algorithm for Pricing Options In this section, we analyze some of the current natureinspired techniques used for financial application such as option pricing. For example, ant colony optimization for option pricing [8], ant brood sorting technique for clustering financial data [33], PSO for derivative pricing problem (DPP) [9] are few unique, first of their kind contribution to the literature. These studies have opened up many strategies for investment analysis based on the market trend and behaviour to study further. Obtaining closed-form analytical solutions for finance problems especially option pricing has been a insurmountable task

for resaerchers. The model equations posed serious challenges for analytical soltuoin and deterministic approches were introduced and through that it was realized that powerful approximation algorithms were needed that could find solutions in reasonable computational time. Some of the applications in finance where implementation of meta-heuristic approach have shown significant results are implied volatility [30], time series forecasting [34] and portfolio selection [35]. The following literature review reveals that more explorations are going on in using heuristic approaches in finance. For example, using neural networks the authors in [36] reported an approch compute financial option value. Genetic programming was used to compute the worth of a financial option in [37]. The authors using genetic programming computed the dependence of option value on various parameters in a financial option contract. This was achieved starting from a known solution from exisiting models such as BSM. The genetic programming was shown to work better in computing option values for multiple styles of option, which was not possible with BSM model. By designing an adaptive genetic programming approach improvement in option prices were shown in [38]. Then generalized ant programming was introduced in [30] for pricing American options and showed that better approximations could be achieved for option value. Ant colony optimization (ACO) technique (see for example [40]) found enormous utility in optimization problems in many real world applications such as in routing and scheduling. A first attempt was reported in [39] in using ACO technique to study financial option pricing application. Later, these authors proposed two ACO based algorithms to price financial options [8]. With this they reported use of ACO for pricing not only vanilla options but also complex options such as barrier option. Their ACO algorithm showed better results than traditional discrete time approach [3] and simulation approach [31]. Real world problems such as routing and scheduling required generating optimal path using ACO, while option pricing required generating a single numerical value for worth of an option contract and a lot of effort was required to design ACO for option pricing. This necessitated newer approaches and techniques for pricing options. For example, in [9] the authors worked with swarm of particles (Particle Swarm Optimization ) [41] to price option contracts. Each particle in the swarm was mapped to parameters in option pricing to capture both the profit (pay off) and the exercise time. The authors had the flexibility with this approach to generate and incorporate a volatility structure in their algorithm. With their implementation European and American options were evaluated and reported PSO to work better than ACO. Recently, in [10], the authors developed a firefly algorithm to solve the multi-objective optimization problem in pricing options. Techniques described earlier had not used such a strategy to evaluate an option contract. These authors modified the base firefly approach to compute the worth of an option contract and validated it by comparing results in conjunction with real market data. In this study, we further investigate

this algorithm with the objective of parallelization of this algorithm on a multi-core GPU machine. As an initial design implementation of parallel algorithm, we have focused on the theoretical performance analysis of our parallel algorithm and experimented in a small scale quad-core machine. Since no earlier results of parallel implementation of other algorithms are available in the similar environment, we have not been to compare the current results with other computational approaches. However, we have compared our results (a) with standard BSM model for accuracy (b) the performance results between sequential and parallel implementation to analyze the overall performance for efficiency. III. FIREFLY ALGORITHM The firefly algorithm is a nature inspired meta-heuristic algorithm used to solve optimization problems. Fireflies are able to produce light through a process of bio-luminescence, most fireflies produce shot and rhythmic flashes. They use these flashes to communicate with each other, possibly to signal others of potential nearby predators, to attract potential prey, and to attract mating partners. Depending on the perceived intensity of the light the fireflies will react accordingly Couple of important parameters in firefly algorithm are: strength of emitted light and solicitation to other Fireflies. Stronger light would mean attractiveness to other fireflies. Hence, strength of the light and solicitation quality are proportional to each other, where the proportionality constant is the ratio of the initial brightness and intensity. The objective function of a problem is linked to the strength of the emitted light. In other words, the variability of light strength is linked to the multi-objective criteria in a given problem. Essentially, this trade-off in the Firefly algorithm acheives the exploration and exploitation strategies required in a meta-heuristic approach very efficiently. This was our main motivation in using Firefly algorithm for the option pricing problem. IV. PARALLEL I MPLEMENTATION We develop a parallel algorithm (Algorithm 5) and study its implementation on a shared memory multi-core machine. We implemented the algorithm on a CPU based and GPU based machine. First, we will explain the the implementation on CPU-based shared memory machines. To parallelize the firefly move method, we partition the fireflies among the number of threads so that each thread iref lies works on approximately #f #T hreads different fireflies. This is valid since the trajectories of each firefly is independent of the others and we are safe to do this in a parallel fashion. There were several issues we needed to handle. On a shared memory system, the threads share a global address space. This may lead to race conditions and synchronization problems thereby degrading performance. Therefore, granularity of tasks allocated to threads is important. Too fine grained (small) tasks, will lead to a lot of unnecessary overhead of spawning threads/joins. We experimented with the granularity and made the tasks large enough to reduce the number of thread spawns/joins.

Unlike distributed memory machines, in which messages are communicated through message passing and there is no access to a computer’s local memory,in a shared memory machine, variables are shared among the threads. If two processors need access to a location xi in memory, the processors have to lock the memory before accessing so that only one processor can write to a memory location to avoid overwriting the data. However, locking causes performance to be slower. We mitigated this by making a separate list of variables local to each thread. Upon completion of the task, the lock is accessed to combine the list with the master list. The sharing id data is necessary when merging the solutions. The firefly move method in theory could be greatly accelerated on the GPU when there is a large number of fireflies. Since a GPU has a much larger count of simple cores that can preform the calculations needed to move the firefly, we will be able to process a much larger volume of fireflies at once. However, there are some issues and it is not easy. On the CPU we can encapsulate all of the fireflies state as an object. However, on the GPU, the programming language CUDA does not support objects which makes representation difficult. The GPU is a data parallel architecture. That is, if the data allocated on each core is of the same size, performance is better. In the algorithm, the set of non-dominated solutions can grow and shrink in size which is unpredictable. Therefore, a core may have more sets another core. This random variability is unavoidable. One solution is to allow the CPU to execute some portions of the algorithm that the GPU is not suited for. In this paper, we provide results for the CPU-based implementation which showed much better promising results than the GPU. Algorithm 1 Firefly movement algorithm for moving a set of fireflies one time step into the future 1: procedure F IREFLY M OVE S TEP (F F List, n) Input: F F List a list of fireflies at their current location and n the number of threads to spawn Output: List L of the current fireflies at the next location 2: Partition the fireflies into n sets {Fi }ni=1 of equal size. 3: Spawn a thread pool T P of size n 4: Create a list L of the same size as F F List to store the new locations of the fireflies 5: for i = 1 to n do 6: TP[i].assignTask( MoveTask, Fi , F F List, L) 7: end for 8: for i = 1 to n do 9: TP[i].join() 10: end for 11: return L 12: end procedure

V. R ESULTS AND D ISCUSSIONS In this section we present our results both theoretical and experimental.

Algorithm 2 Firefly movement Task 1: procedure M OVE TASK (F F List1, F F List2, L) Input: F F List1 a list of fireflies to move relative to fireflies in F F List2 and store them in the list L 2: for FFi in F F List1 do 3: newFFi = FFi .copy() 4: for FFj in F F List2 do 5: if FFi .f itness < FFj .f itness then 6: newFFi .moveT owards(FFj ) 7: end if 8: end for 9: newFFi .prob = M CEst(newFFi ) 10: L[i] = newFFi 11: end for 12: end procedure Algorithm 3 Find Non-dominated set 1: procedure F IND N ON D OM S ET (F F List, n) Input: F F List a list of fireflies and n the number of threads to spawn Output: A list of non-domination fireflies 2: Partition the fireflies into n sets {Fi }ni=1 of equal size. 3: Spawn a thread pool T P of size n 4: Create empty list L to store the non-dominated fireflies 5: for i = 1 to n do 6: TP[i].assignTask( NonDomTask, Fi , F F List, L) 7: end for 8: for i = 1 to n do 9: TP[i].join() 10: end for 11: return L 12: end procedure

A. Theoretical Analysis There are four procedures in the algorithm (Algorithms 1-4): move, finding single dominated set, finding all dominated sets and merging. Here we denote n to be the size of the firefly population, m to be the number of iterations the algorithm is to be run, and P to be the number of processes used for computation. We assume P ≤ n. 1) Firefly Move Cost: In order to update the position of a single firefly we need to compare its fitness level to the remaining n − 1 fireflies. This computation in parallel, each firefly writing to a new memory location, with no race conditions. Therefore, the cost of a single iteration of the move method is at most c ∗ n ∗ (n − 1), where c is a constant which takes into account the cost of reading from memory, comparing between the old and new value, and updating the value if necessary. Given P processes available, each process assigned c ∗ n ∗ (n − 1) cycles to to a firefly, the estimated cost is P preform the move method. 2) Finding single non-dominated sets: To find the nondominated set of solutions each firefly needs to determine if there is another firefly in the same population which is strictly

Algorithm 4 Firefly Non-dominated Task 1: procedure N ON D OM TASK (F F List1, F F List2, L) Input: F F List1 a list of fireflies to be compared to fireflies in F F List2 and store the non-dominated ones in the list L 2: Create new empty list tmpList private to this method 3: for FFi in F F List1 do 4: isNonDom = True 5: for FFj in F F List2 do 6: if FFj dominates FFi then 7: isNonDom = False 8: end if 9: end for 10: if isNonDom then 11: tmpList.add(FFi ) 12: end if 13: end for 14: L.mutex.lock() 15: for FFi in tmpList do 16: L.add(FFi ) 17: end for 18: L.mutex.unlock() 19: end procedure

Algorithm 5 Parallel Non-dominated Firefly Sorting 1: procedure P-NDFS(numOfIters, popSize, threadCount, numOfTradingDays, initStockPrice, σ) Input: 2: Create new list currP op of size popSize and initialize it with random fireflies in the search space 3: Create empty list nonDom 4: for i = 1 to numOf Iters do 5: nextP op = FireflyMoveStep(currP op, threadCount)  6: comboP op = currP op nextP op 7: listOfFronts = FindNonDomSet(comboP op, threadCount)  8: nonDom = nonDom listOfFronts[0] 9: listOfFronts = FindNonDomSet(nonDom, threadCount) nonDom = listOfFronts[0] currP op = nextP op 10: end for return nonDom 11: end procedure

better than itself. Each firefly compares itself to the other n−1 fireflies. Since each firefly can do this in parallel, the cost isat 2 n ∗ (n − 1) . Hence it takes O( nP ) time to find the nonmost P dominated set on n elements with P processes. 3) Finding all the non-dominated sets: In order to update the fitness of a firefly we need to know in what level of nondomination it is in. In the previous section we saw that it cost 2 O( nP ) to find a single non-dominated set. However, we need to recursively look at the dominated set to find the next level of non-domination, and rearrange (move) the fireflies around between the sets. In the worst case, there would be a single firefly at every level of non-domination. Then, there would be n subproblem ranging from size n to 1 and since it takes quadratic cost in the input size we have in the worst case, 3 it will take O( nP ) cycles to find all of the different levels of non-domination. In the best case we only have a constant number of non-domination fronts at each iteration, which is what we observe in our experiments. 4) Merging current solution with best known solutions: Merging the set of current best known solutions with the new ones found involves find a single non-dominated set. Since we know that the cost of finding a non-dominated set per process is O(k 2 /P ), where k is the size of the set. In the worst case the size of the best solutions could grow by a constant fraction of n at each iteration leading to a size of c ∗ i ∗ n on the i-th 2 2 ). iteration. We get that the cost in the worst case is O( n ∗m P In our experiments we found that the size of best solutions did not grow n ∗ m but rather it was a small fraction of n. 5) Total Cost: To get the total cost over m iterations of the algorithm we add each of the steps at each iteration. This is 2 2 3 ) in on the order of O( n P∗m ) in the idea case and O( n ∗m P the absolute case. B. Experimental Results The algorithm was implemented on multi-core CPU machine using POSIX pthreads in C++17 and tested on an Intel Haswell i7-4700HQ processor with 4 cores and 8 threads. We also implemented the sequential version of the algorithm that does not make any fork/join or any mutex lock/unlock calls to establish a baseline for performance. Figures 1 and 2 capture our experimental results. We have run various tests comparing the runtime when using a different number of threads and fixing one of the two variables, population size or the number of iterations, while varying the other variable. In Figure 1 we plot the execution time (in seconds) for various number of iterations of the algorithm with varying number of threads. The linear increase in time for number of iterations is clearly and consistently observed from this figure. The execution time with two threads is worse than the sequential implementation. This is because each thread executes a coarse-grained amount of work, overloading each thread. However, as we increase the threads, the work load of fireflies gets the distributed among many threads and hence the execution is reduced from 580 seconds (sequential) to about 390 seconds with 8 threads after 50 iterations - about 32%

efficiency. For four threads the efficiency is about 16% and hence as we double the number of threads the speedup is doubled. In other words, through these experiments we are able that the firefly parallel algorithm shows an increased performance as number of threads are increased. Figure 2 shows execution time versus the number of fireflies. As we increase the number of fireflies, the workload is distributed among the various fireflies. However, there is a threshold as to how much it increases. In the experiments, the threshold is 8 threads with 25,000 fireflies which is better that the sequential implementation. This shows that there is a direct relation between the number of threads and number of fireflies. Given p threads and n number of fireflies, n/p amount of work is distributed among the threads. As p increases the amount of work decreases per thread but the amount of parallelism increases. The communication between the threads may also increase since the partner fireflies may be allocated to different threads. The data is shared in global memory which is slow and synchronization and race conditions on shared data becomes an issue. We also noticed that if we fix the number of threads and decrease the number of fireflies, the amount of work decreases per thread reducing parallelism. Therefore, as we vary the number of threads, the number of fireflies also have to varied to keep all threads busy to achieve scalability. The speedup with respect to the sequential implementation on four threads with 25,000 fireflies is 20% compared to 32% for 5000 fireflies on four threads. This indicates that the number of threads needed is proportional to the number of fireflies. Also, increasing the number of iterations increases the execution time but provides better accuracy. We also compared the results produced by our model to that of the Black–Scholes–Merton model separately to verify that we are in fact producing reasonable predictions for the options.

Figure 2. Execution time for various number of Fireflies

VI. C ONCLUSIONS In this paper, we studied the financial option pricing problem using the firefly swarm intelligence technique. We designed and developed a parallel firefly algorithm on shared memory machines. We analyzed the algorithm theoretically and implemented the algorithm on CPU and GPU-based machines. Although, the GPU provides lot more cores and the firefly algorithm is better suited for the GPU, frequent access to global memory by the algorithm caused performance degradation. However, on CPU-based machines, the parallel version was able to out preform the serial version when the number of threads is high, and is up to 30-40% better than the serial version. Redesign of the parallel algorithm and implementation is required to better manage access to global memory and reduce cost due to memory latency and hence increase the performance further. We leave this work as a future work. ACKNOWLEDGMENT The second and third authors acknowledge the financial support from Natural Science and Engineering Research Council (NSERC) Canada through the Discovery Grant program. The last author acknowledges the Fellowship from the Association of Commonwealth Universities to visit University of Manitoba, Canada on a research collaboration. R EFERENCES

Figure 1. Execution time for various iterations

[1] Black, Fischer and Scholes, Myron, The pricing of options and corporate liabilities, The journal of political economy, pp.637–654, 1973, The University of Chicago Press. [2] Merton, Robert. C, Theory of Rational Option Pricing, Bell journal of economics and Management Science, pp. 141-183, 1973, RAND Corporation. [3] Cox, John C and Ross, Stephen A and Rubinstein, Mark, Option pricing: A simplified approach, Journal of Financial Economics, vol.7, no.3, pp.229–263, 1979, Elsevier. [4] Hull, John C., Options, Futures and Other Derivatives, 9th edition, Prentice Hall, 2014. [5] Jiang, Lishang and Li, Canguo, Mathematical modeling and methods of option pricing, World Scientific, 2005. [6] Brennan, Michael, J and Schwartz, Eduardo S., Finite difference methods and jump processes arising in the pricing of contingent claims: A synthesis, Journal of Financial and Quantitative Analysis, Vol. 13, No.3, pp.461–474, 1978, Cambridge Univ Press.

[7] Cerny, Ales, Mathematical Techniques in Finance - Tools for Incomplete Markets, 2004, Princeton Univ. Pres,, NJ, USA. [8] Kumar, Sameer and Chadha, Gitika and Thulasiram, Ruppa K and Thulasiraman, Parimala, Ant Colony Optimization to Price Exotic Options, Proceedings of the 2009 IEEE Congress on Evolutionary Computation Conference, Trondheim, Norway, pp. 2366–2373, 2009. [9] Thulasiram, Ruppa K. and Thulasiraman, Parimala, and Prasain, Hari and Jha, Girish, Nature- Inspired Soft Computing for Financial Option Pricing using High Performance Analytics, Concurrency and Computation: Practice and Experience, Vol.28, pp.707-728, 2016, Wiley InterScience. [10] Singh, Gobind Preet and Thulasiram, Ruppa K and Thulasiraman, Parimala, Non-Dominant Sorting Firefly Algorithm for Pricing American Option, Proceedings of the 2016 IEEE Symposium on Computational Intelligence in Financial Engineering and Economics (CIFEr) in Swarm and Computational Intelligence (SSCI) Conference, Athens, Greece, 2016. [11] Thulasiram, Ruppa K and Litov, Lubomir and Nojumi Hassan and Downing, Christopher T and Gao, Guang R., Multithreaded Algorithms for Pricing a Class of Complex Options, Proceedings of the 2001 IEEE/ACM International Parallel and Distributed Processing Symposium, SanFrancisco, USA, 2001. [12] Thulasiram R, Thulasiraman P., Pricing Algorithms for Financial Derivatives, Chapter 33. Atallah M, Blanton M. Handbook of Algorithms and Theory of Computation; pp. 33.1 - 33.25, 2009, CRC Press. [13] Sharma B, Thulasiram R, Thulasiraman P., Normalized particle swarm optimization for complex chooser option pricing on graphics processing unit,. The Journal Supercomputing. Vol.66, No.1, pp. 170-192, 2013. [14] Franz W, Thulasiraman P, Thulasiram R., Exploration/Exploitation of a Hybrid Enhanced MPSO-GA Algorithm on a Fused CPU-GPU Architecture. Wiley InterScience Concurrency and Computation: Practice and Experience.(Appeared on-line first in July 2014). [15] Wang J, Osagie E, Thulasiraman P, Thulasiram R. HOPNET: A Hybrid ant colony OPtimization routing algorithm for mobile ad hoc NETwork,. Elsevier Ad Hoc Networks Journal. Vol.7, No.4, pp.690-705, 2009. [16] Solomon S, Thulasiraman P, Thulasiram R. (2013). Scheduling using

[17]

[18] [19]

[20]

[21]

[22]

[23] [24]

[25]

[26]

[27]

Multiple Swarm Particle Optimization with Memetic Features on Graphics Processing Units, Chapter 8. Tsutsui S, Collet P. Massively Parallel Evolutionary Computation on GPGPU. pp. 149-178, 2013 F. S. Emmanuel, E. O. Helen, On hybrid model for the valuation of credit risk, Applied and Computational Mathematics, Vol.3, No.1, pp.811, Aug. 2014. Duan J. C., The GARCH Option Pricing Model, J. Math. Fin., Vol.5, No.1, pp.13-32, 1995. P.Ritcthken and R.Trevor, ”Pricing Options Under Generalized GARCH and Stochastic Volatility Processes”, J. Finance, Vol.54, No.1, pp.377402,1999. N.Cakici and K.Topyan, “GARCH versus Constant Volatility: A Lattice Approach in Option Pricing”, Proc. Assoc. of Employment Practices and Principles Conf., NY, USA,1999. Y. Lyuu, and C. Wu, On accurate and provably efficient GARCH option pricing algorithms, Quantitative Finance, Vol.5, No.2, pp.181-198, April 2005. Allenotor D, Ola B, Thulasiram R., Option Pricing in a GARCH Framework. IEEE African Journal of Computing and ICT. Vol.6, No.2, pp. 91-104, 2013. J.C. Duan et al., Approximating the GJR-GARCH and EGARCH option pricing models analytically, J. Comp. Fin., Vol.9, No.3, 2004. Carr, P. and Madan, D.B., Option Valuation using the Fast Fourier Transform. The Journal of Computational Finance, Vol.2, No.4, pp.61–73, 1999. Barua S., Thulasiram, Ruppa K., Thulasiraman, P., High Performance Computing for a Financial Application Using Fast Fourier Transform, Proc. of the European Parallel Computing Conference, Euro-Par 2005, LNCS 3648, pp. 1246–1253, 2005. Thulasiram, Ruppa K., Special Issue on Parallel and Distributed Computing in Finance, Guest Editor’s Preface, Parallel Computing Systems and Applications, Vol. 36, No.7, July 2010, Elsevier. Thulasiram, Ruppa K., and Parashar, M., Special Issue on Computational Finance, Guest Editors’ Preface, Concurrency Computation: Practice and Experience, Wiley 2014

[28] Haugh, M.B., and Lo, A.W., Computational challenges in portfolio management - tomorrow’s hardest problem. Computing in Science and Engineering, Vol.3, No.3, pp.54–59, May-June 2001. [29] Zenios, S.A., High-Performance Computing in Finance: The Last 10 Years and the Next. Parallel Computing, Vol.25, pp.2149– 2075, Dec. 1999. [30] Keber, Christian and Schuster Matthias G., Option Valuation With Generalized Ant Programming, Proceedings of the Genetic and Evolutionary Computation Conference (GECCO) 2002, pp.74-81, 2002, New York. [31] Boyle, P.P., Options: A Monte-Carlo approach. J. of Financial Economics, Vol.4, No.3, pp.323–338, 1977. [32] Chen, Gong, Thulasirman, P., Thulasiram, Ruppa K., Distributed Adaptive Quasi Monte-Carlo Algorithm for Option Pricing on HNOWs using mpC, Proc. (CD-RoM) of the Annual Simulation Symposium, May 2006. [33] Oduntan I, Thulasiraman P, Thulasiram R., Portfolio Diversification Using Ant Brood Sorting Clustering. Proc. of the 6th IEEE World Congress on ”Nature and Bio Inspired Computing” (NaBIC), Porto, Portugal, July 2014, pp.256-261. [34] Zhang, G Peter, Time series forecasting using a hybrid ARIMA and neural network model, Elsevier Neurocomputing, vol.50, pp.159–175, 2003. [35] Doerner, Karl and Gutjahr, Walter J and Hartl, Richard F and Strauss, Christine and Stummer, Christian, Pareto ant colony optimization: A metaheuristic approach to multiobjective portfolio selection, Vol. 131, Springer Annals of operations research, No.1-4, pp.79-99, 2004. [36] Hutchinson, James M and Lo, Andrew W and Poggio, Tomaso, A nonparametric approach to pricing and hedging derivative securities via learning networks, The Journal of Finance, vol. 49, No.3,pp.851-889, 1994, [37] Chidambaran, N K and Lee, Chi-Wen Jevons and Trigueros, Joaguin R., An adaptive evolutionary approach to option pricing via genetic programming,NYU Working Paper No. FIN-98-086, 1998 [38] Yin, Zheng and Brabazon, Anthony and O’Sullivan, Conall, Adaptive genetic programming for option pricing, Proceedings of the 9th annual

ACM conference companion on Genetic and evolutionary computation (GECCO), pp.2588–2594, 2007. [39] Kumar, Sameer and Thulasiram, Ruppa K and Thulasiraman, Parimala, A bioinspired algorithm to price options, ACM Proceedings of the 2008 C3S2E conference, pp. 11–22, 2008. [40] Dorigo, Marco and Birattari, Mauro, Ant colony optimization, Springer Encyclopedia of machine learning, pp.36–39, 2010, [41] Kennedy, James, Particle swarm optimization, Springer Encyclopedia of Machine Learning, pp. 760–766, 2010.