Feel free to Contact Me with any changes/updates.

[1] R. A. Formato, “Central force optimization: A new metaheuristic with applications in applied electromagnetics,” Progress in Electromagnetics Research, PIER 77, pp. 425–491, 2007.

[2] R. A. Formato, “Central Force Optimization: A New Nature Inspired Computational Framework for Multidimensional Search and Optimization,” in NICSO.
Springer-Verlag, 2007, pp. 221–238.

[3] R. A. Formato, “Central Force Optimization: A New Deterministic Gradient-Like Optimization Metaheuristic,” Journal of the Operations Research Society of India, vol. 46, no. 1, pp. 25–51, 2009.

[4] R. A. Formato, “Are Near Earth Objects the Key to Optimization Theory?” Computing Research Repository, no. arXiv:0912.1394, December 2009.

[5] R. A. Formato, “Central force optimisation: A new gradient-like metaheuristic for multidimensional search and optimisation,” Interational Journal of Bio-Inspired Computation, vol. 1, no. 4, pp. 217–238, 2009.

[6] G. Mohammad and N. Dib, “Synthesis of Antenna Arrays Using Central Force Optimization,” in Mosharaka International Conference on Communications, Computers and Applications, Amman, Jordan, 2009.

[7] G. Qubati, “Central force optimization method and its application to the design of antennas,” Master’s thesis, Jordan University of Science and Technology, 2009.

[8] R. A. Formato, “Improved CFO Algorithm for Antenna Optimization,” Progress in Electromagnetics Research, PIER B, vol. 19, pp. 405–425, 2010.

[9] R. A. Formato, “Comparative Results: Group Search Optimizer and Central Force Optimization,” Computing Research Repository, vol. abs/1002.2798, 2010.

[10] R. A. Formato, “Pseudorandomness in Central Force Optimization,” Computing Research Repository, vol. abs/1001.0317, 2010.

[11] R. A. Formato, “Central Force Optimization Applied to the PBM Suite of Antenna Benchmarks,” Computing Research Repository, vol. abs/1003.0221, 2010.

[12] R. A. Formato, “Parameter-Free Deterministic Global Search with Central Force Optimization,” Computing Research Repository, vol. abs/1003.1039, 2010.

[13] R. A. Formato, “On the Utility of Directional Information for Repositioning Errant Probes in Central Force Optimization,” Computing Research Repository, vol. abs/1005.5490, 2010.

[14] G. M. Qubati and N. I. Dib, “Microstip Patch Antenna Optimization Using Modified Central Force Optimization,” Progress in Electromagnetics Research B, vol. 21, pp. 281–298, 2010.

[15] D. Ding, X. Luo, J. Chen, X. Wang, P. Du, and Y. Guo, “A Convergence Proof and Parameter Analysis of Central Force,” Journal of Convergence Information Technology, vol. 6, no. 10, pp. 16–23, 2011.

[16] R. A. Formato, “Central Force Optimization with variable initial probes and adaptive decision space,” Applied Mathematics and Computation, vol. 217, no. 21, pp. 8866–8872, 2011.

[17] R. Green, L. Wang, M. Alam, and R. Formato, “Central Force Optimization on a GPU: A case study in high performance metaheuristics using multiple topologies,” in IEEE Congress on Evolutionary Computation, New Orleans, Los Angeles, June 2011, pp. 550–557.

[18] K. R. Mahmoud, “Central Force Optimization: Nelder-Mead Hybrid Algorithm for Rectangular Microstrip Antenna Design,” Electromagnetics, vol. 31, no. 8, pp. 578–592, 2011.

[19] R. Green, L. Wang, and M. Alam, “Training neural networks using Central Force Optimization and Particle Swarm Optimization: Insights and comparisons,” Expert Systems with Applications, vol. 39, pp. 555–563, January 2012.

[20] R. Green, L. Wang, M. Alam, and R. A. Formato, “Central force optimization on a GPU: A case study in high performance metaheuristics,” Journal of Supercomputing, pp. 1–21, 2012, article in press.

[21] A. Haghighi and H. M.Ramos, “Detection of Leakage Freshwater and Friction Factor Calibration in Drinking Networks Using Central Force Optimization,” Water Resources Management, vol. 26, no. 8, pp. 2347–2363, March 2012. [Online]. Available: http://rd.springer.com/article/10.1007/s11269-012-0020-6

[22] N. Dib, A. Sharaqa, and R. A. Formato, “Variable Z0 applied to Biogeography Based Optimized Multi-Stub Matching Network and to a Central Force Optimized Meander Monopole,” April 2012, submitted for Publication.

$(function(){
    var loadingMessage = "Message/Image here";
    $('#tabs').tabs({
        show: function(e, u){
            $.blockUI({message: loadingMessage});
        },
        load: function(e, u){
            $.unblockUI();
        }
    });
});

1. Install the binary version of OpenMPI from here;
2. Install the binary version of OpenMPI;
3. Download the latest version of Boost, currently 1.49.0 from here;
4. Extract the boost libraries;
5. Open up the "tools\build\v2" directory in the boost source;
6. Edit the user-config.jam and add the following line anywhere in the file:

            using mpi : "C:/Program Files (x86)/OpenMPI_v1.5.5-win32/bin/mpicc.exe"
                      : <find-shared-library>lammpio <find-shared-library>lammpi++
                        <find-shared-library>mpi <find-shared-library>lam
                        <find-shared-library>dl ;
        

7. Made sure the GCC binaries were in my path;
8. Open up a command prompt (probably a Visual Studio command prompt);
9. I used the following commands to build the libraries:

        bootstrap.bat
        b2.exe --build-type=complete --toolset=gcc
        

Now I'm sitting here watching the library build. I'll post updates as the come.

Now, if you just download cuSVM and open up the Visual Studio solution, you will be a bit dissapointed as it does not compile and is not contained in a CUDA project. In order to correct this, I took the steps listed below. While I encourage you to read the steps and complete this process yourself, you may also download the files used in this project by clicking here.

1. Create a new CUDA 4.0 Project called "cuSVMPredict"
2. Create a new CUDA 4.0 Project called "cuSVMTrain"
3. Add the appropriate files from the original cuSVM project. This is done by copying each file into the correct location on the file system, right-clicking on the project and selecting "Add -> Existing Item...". The files needed include:
   • For cuSVMPredict: cuSVMPredict.cpp, cuSVMPredictKernel.cu, PredictModule.def
   • For cuSVMTrain: cuSVMTrain.cpp, cuSVMSolver.cu, TrainModule.def
   • Copy the "inc" directory into the root of the solution
4. Open up the file "cuSVMSolver.cu" in the "cuSVMTrain" project
5. Add "using namespace std;" on line 17, after the final include statement
6. For each project, right-click on the project and select "Properties"
7. Make the following changes:
   1. Under "Configuration Properties -> General":
      • Change "Target Extension" to ".mexw32"
      • Change "Configuration Type" to "Dynamic Library (.dll)"
   2. Under "Configuration Properties -> C/C++ -> General -> Additional Include Directories":
      • Add your Matlab include directory (MATLABDIR\extern\include)
      • Add "..\inc"
      • Add the CUDA GPU Computing SDK include directory. On Windows 7 this is "C:\ProgramData\NVIDIA Corporation\NVIDIA GPU Computing SDK 4.0\C\common\inc"
   3. Under "Configuration Properties -> CUDA C/C++ -> Common -> Additional Include Directories":
      • Add your Matlab include directory (MATLABDIR\extern\include)
      • Add the CUDA GPU Computing SDK include directory. On Windows 7 this is "C:\ProgramData\NVIDIA Corporation\NVIDIA GPU Computing SDK 4.0\C\common\inc"
   4. Under "Configuration Properties -> Linker -> General -> Additional Library Directories":
      • Add your Matlab include directory (MATLABDIR\extern\lib\win32\microsoft)
      • Add the CUDA GPU Computing SDK bin directory. On Windows 7 this is "C:\ProgramData\NVIDIA Corporation\NVIDIA GPU Computing SDK 4.0\C\common\bin"
   5. Under "Configuration Properties -> Linker -> Input -> Additional Dependencies":
      • Add "cuda.lib"
      • Add "cublas.lib"
      • Add "libmex.lib"
      • Add "libmat.lib"
      • Add "libmx.lib"
8. Right-click on the solution and select "Build Solution"

Having completed these steps, you should be good to go.

1. Create a ".cu" file for your kernels;
2. For each kernel you would like to call from C++, create a wrapper that can be called from inside your class;
3. Inside this wrapper, call your kernel function;
4. Include the prototype for your wrapper in the header file of your class, but not inside the class definition.

An example of the ".cu" file and the class header are shown below. One thing you apparently do not need to do (particularly in Visual Studio 2010) is include the ".cu" file in your class. As long as it is part of your project, everything should work just fine.

#ifndef _PROJECT_KERNELS
#define _PROJECT_KERNELS

__global__ void kernel(double Param1, double Param2){
    // Do Kernel Stuff here
}
extern "C" void functionName(double Param1, double Param2){

    kernel<<<Nb, Nt>>kernel(Param1, Param2);
}
#endif

#ifndef MYCLASS_H_
#define MYCLASS_H_

#include <cuda.h>
#include "cuda_runtime.h"

extern "C" void functionName(double Param1, double Param2);

class myClass{
    myClass();
}
#endif

While at pragprog.com, I stumbled across their magazine, PragPub. In the September 2009 magazine there is a wonderful article titled, "Beauty in Code." The entire article deals with understanding the function and meaning of these unique snippets of code. While this is a fun challenge (I may use this in the classroom someday), it makes a solid point regarding development that is very well stated in the article:

We translate user stories into source code. How much of it survives the operation? More importantly, how much of it gets lost in the translation?

The issue being dealt with here is clarity. Clarity in code is vital and adds directly to the beauty of what is being developed in both form in function. While I could rant on this topic for quite some time, I will simply let this simmer for a while.

I leave you with two excellent quotes. The first is from the article I've discussed and the other is from Java.next #4: Immutability.

If you do it right, the beauty you see is multifaceted. If the code (as it runs) is as beautiful as the code (as it is written), then you are singing it just right.

Languages are not about what they make possible, but about what they make beautiful.

There’s 60 years of existing scientific knowledge buried in code and it’s extremely difficult to extract. As scientists write new code, they need to clearly ex­press intent in a way that doesn’t affect code performance.

This reinforces the idea that there is a huge issue concerning the writing of clear, concise, and understandable code in industry and academics. In light of this idea, I've recently published an article with Henry Ledgard titled "Coding Guidelines: Finding the Art in the Science" that can be found here and here. The article itself is focused on the idea that there is a role that aesthetics plays when writing code. This is perhaps summed up best by the first few lines of the article:

Computer science is both a science and an art. Its scientific aspects range from the theory of computation and algorithmic studies to code design and program architecture. Yet, when it comes time for implementation, there is a combination of artistic flare, nuanced style, and technical prowess that separates good code from great code.

This article, as opposed to those that layout strict coding guidelines to increase performance and maintainability, is focused on developing code that is easier to read by focusing on the aesthetic appeal of the code. And, while it has not been studied yet, code that appeals to developers in this fashion should lead to 1) Easier maintenance, 2) Increased productivity, and 3) A shorter period of acclimation when working with an unfamiliar code base.

In the paper, we present 6 distinct guidelines that should be followed as much is possible:

1. Consider a program as a table;
2. Let simple English be your guide;
3. Rely on context to simplify code;
4. Use white space to show structure;
5. Let decision structures speak for themselves; and
6. Focus on the code, not the comments.

Some of these ideas are controversial and some people will see a few things that we have presented as impractical. That is why we have presented our ideas as "guidelines", not "standards". This is a flexible set of ideas that can be molded to fit individuals and corporations alike.

Beyond this, the use of aesthetics in coding suggests that there are some general principles that will aid in making code appealing to nearly everyone, though there will be some nuances between different developers.

One thing I would like to mention is that some folks have pointed out some errors in the Figures (particularly Figure 1). I would encourage readers not to lose sight of the "forest for the trees" in this situation as requests have been made to fix these minor errors. This is particularly true as the guidelines are intended to be IDE, language, and syntax neutral. Thus, the visual appeal (and the point) of the examples should be apparent regardless.

First, the clarity and the ability of code to communicate intent clearly are very important. If I could only find a way to articulate how important clarity and communication are for code stability, I would, but I find that anything I say does not express this clearly enough. So, from the article:

"There’s 60 years of existing scientific knowledge buried in code and it’s extremely difficult to extract. As scientists write new code, they need to clearly ex­press intent in a way that doesn’t affect code performance. Code structures are one way to help capture intent and knowledge, yet they don’t impede performance."

Second, results of what you code must be verified somehow. Again, from the article:

"One panelist pointed out that testing results in “reviewing the output instead of reviewing the code.”Everyone agrees that code review is a good idea. However, it’s difficult to incorporate code review into work practices without the large overhead it commonly entails."

So, if you are writing code, please consider the clarity and intent of what you are writing. This is important and will save many developers, scientists, and others hours of wasted time. Also, if you write scientific code, please share it with the community. Critiquing code, verifying results, and extending algorithms would be much easier if there was a real atmosphere of cooperation out there.

The code below is intended to get you started working with PSO in Matlab or Octave. Best efforts were made to keep the code clean and easy to understand. Feel free to play with it and contact me with any questions.

Click Here to Download PSO.m

Downloads: PDF | Bibtex

[1] Q. Yu, C. Chen, and Z. Pan, “Parallel genetic algorithms on programmable graphics hardware,” in Lecture Notes in Computer Science
3612. Springer, 2005, p. 1051.

[2] P. Pospichal and J. Jaros, “GPU-based Acceleratino of the Genetic Algorithm,” in Proceedings of GECCO 2009, 2009.

[3] A. Munawar, M. Wahib, M. Munetomo, and K. Akama, “Hybrid of genetic algorithm and local search to solve max-sat problem using NVIDIA CUDA framework,” Genetic Programming and Evolvable Machines, vol. 10, pp. 391–415, 2009.

[4] S. Debattistic, N. Marlat, L. Mussi, and S. Cagnoni, “Implementatino of a Simple Genetic Algorithm within the CUDA Architecture,” in Proceedings of GECCO 2009, 2009.

[5] S. Zhang and Z. He, “Implementation of parallel genetic algorithm based on cuda,” in Advances in Computation and Intelligence, ser. Lecture Notes in Computer Science, Z. Cai, Z. Li, Z. Kang, and Y. Liu, Eds. Springer Berlin / Heidelberg, 2009, vol. 5821, pp. 24–30.

[6] S. Tsutsui and N. Fujimoto, “Solving quadratic assignment problems by genetic algorithms with gpu computation: a case study,” in Proceedings of the 11th Annual Conference Companion on Genetic and Evolutionary Computation Conference: Late Breaking Papers, ser. GECCO ’09. New York, NY, USA: ACM, 2009, pp. 2523–2530.

[7] P. Vidal and E. Alba, “A multi-gpu implementation of a cellular genetic algorithm,” in 2010 IEEE Congress on Evolutionary Computation (CEC), July 2010, pp. 1–7.

[8] ——, “Cellular genetic algorithm on graphic processing units,” in Nature Inspired Cooperative Strategies for Optimization (NICSO 2010), ser. Studies in Computational Intelligence, J. Gonzlez, D. Pelta, C. Cruz, G. Terrazas, and N. Krasnogor, Eds. Springer Berlin/Heidelberg, 2010, vol. 284, pp. 223–232.

[9] R. Arora, R. Tulshyan, and K. Deb, “Parallelization of binary and real-coded genetic algorithms on GPU using CUDA,” in IEEE Congress on Evolutionary Computation, 2010, pp. 1–8.

[10] N. Fujimoto and S. Tsutsui, “A highly-parallel tsp solver for a gpu computing platform,” in Proceedings of the 7th international conference on Numerical methods and applications, ser. NMA’10. Berlin, Heidelberg: Springer-Verlag, 2011, pp. 264–271.