This is the first release of PSO! makefiles for OSX and Linux only, borrowed from pool and prepend.svn2git-root

svn path=/trunk/externals/bbogart/; revision=1054

6 files changed, 1043 insertions, 0 deletions

diff --git a/pso/COPYING.txt b/pso/COPYING.txt
new file mode 100644
index 0000000..486449c
--- /dev/null
+++ b/pso/COPYING.txt
@@ -0,0 +1,340 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/pso/README.build.txt b/pso/README.build.txt
new file mode 100644
index 0000000..fdb40c4
--- /dev/null
+++ b/pso/README.build.txt
@@ -0,0 +1,19 @@
+These objects where developed under Linux and have been tested 
+on Linux. The objects should also compile under all other flext capable platforms.
+makefiles have only been provided for OSX and Linux.
+
+Note: Flext is required to compile this external!
+
+To build & Install (under linux):
+
+   edit makefile.pd-linux to suit your needs
+
+   make -f makefile.pd-linux
+
+To build & Install (under OSX):
+
+   edit makefile.pd-darwin to suit your needs
+
+   make -f makefile.pd-darwin
+
+See http://www.ekran.org/ben/research/pso for binary PD and MAX releases.
diff --git a/pso/README.txt b/pso/README.txt
new file mode 100644
index 0000000..b5a2b2b
--- /dev/null
+++ b/pso/README.txt
@@ -0,0 +1,51 @@
+This is the readme for "PSO" a Particle Swarm Optimizer object for PD/MAX. 
+
+This implimentation of a PSO minimizes towards a user-defined target. It is based on code from Jim Kennedy and Thomas Grill.
+
+PSO is Copyright Ben Bogart 2003
+
+If you have any questions/comments you can reach the author at ben@ekran.org.
+
+This program is distributed under the terms of the GNU General Public 
+License 
+
+PSO is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or 
+(at your option) any later version.
+
+PSO is distributed in the hope that it will be useful, 
+but WITHOUT ANY WARRANTY; without even the implied warranty of 
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details. 
+
+You should have received a copy of the GNU General Public License
+along with PSO; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+USAGE:
+
+The PSO object requires three arguments (see below). The object has one inlet and three outlets. 
+In order to calculate one iteration of the PSO send it a bang. The three outlets are:
+
+Outlet 1: A index prepended list of the positions in each dimention of each particle.
+Outlet 2: The Minimization value (should move towards 0)
+Outlet 3: Outputs a bang when Minimization is reached. (This is a user defined threshold, not 0)
+
+Arguments: [Population Size] [Number of Dimensions] [Neighborhood Size]
+
+PSO Help Method:
+  'help'                        - This message.
+
+PSO Setup Methods:
+  'target [list]'               - Specify the optimization target with list of values for each dimension.
+  'rand_pop [min] [max]'        - Randomize the population with values ranging from min to max.
+  'set_pop [list]'              - Set population with list of values for each particle for each dimension.
+  'set_part [particle] [list]'  - Set particle with values for each dimension.
+  'optim_thresh [int]'          - Set the threshold at which minimization is considered reached. (0-10)
+
+PSO Run-Time Methods:
+  'reset'                       - Reset the PSO.
+  bang                          - Calculate one interation of the PSO.
+
+Have Fun.
diff --git a/pso/main.cpp b/pso/main.cpp
new file mode 100644
index 0000000..5837530
--- /dev/null
+++ b/pso/main.cpp
@@ -0,0 +1,486 @@
+/*##############################################################################
+#                                                                              #
+#   This file is part of PSO (Particle Swarm Optimizer)                        #
+#   Copyright Ben Bogart 2003, based on code from Thomas Grill & Jim McKenzie  #
+#                                                                              #
+#   This program is free software; you can redistribute it and/or modify       #
+#   it under the terms of the GNU General Public License as published by       #
+#   the Free Software Foundation; either version 2 of the License, or          #
+#   (at your option) any later version.                                        #
+#                                                                              #
+#   This program is distributed in the hope that it will be useful,            #
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of             #
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
+#   GNU General Public License for more details.                               #
+#                                                                              #
+#   You should have received a copy of the GNU General Public License          #
+#   along with this program; if not, write to the Free Software                #
+#   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  #
+#                                                                              #
+##############################################################################*/
+
+// include flext header
+#include <flext.h>
+#include <stdlib.h>
+#include <math.h>
+
+// check for appropriate flext version
+#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 400)
+#error You need at least flext version 0.4.0
+#endif
+
+class pso:
+	// inherit from basic flext class
+	public flext_base
+{
+	// obligatory flext header (class name,base class name)
+	FLEXT_HEADER(pso,flext_base)
+ 
+public:
+	// constructor 
+	pso(int Popsize, int Dimen, int HoodSize);
+
+protected:
+
+	// override default flext help function
+        virtual void m_help();
+
+	// flext deconstructor
+	~pso();
+
+	// PSO Functions
+	void init();					// Initialize the PSO 
+	void copy_positions();				// Copy the current positions to previous positions
+	float minimize(int particle);			// The function to Minimize (sphere)
+	void set_pop(int argc,t_atom *argv);  		// Set values to the population
+	void set_particle(int argc,t_atom *argv);	// Set values for a single particle
+        void set_target(int argc,t_atom *argv);         // Set the PSO target
+	void rand_pop(float min, float max);		// Randomize the values of the population
+	void optim_thresh(float threshold);		// Optimization Threshold
+	void rand_vel();				// Randomize the velocities
+	void iterate(); 				// Iterate the PSO
+	void reset();					// Rerun the PSO init
+	void output_positions();			// Send out the lists of Particles' positions
+
+	// PSO Init Variables
+	int popsize;
+	int dimen;
+	int hoodsize;
+	int gbest;
+	float Min;
+	float Max;
+	float optimization_threshold;
+
+	// PSO Arrays
+        float *current_position;
+        float *velocity;
+        float *previous_best_position;
+        int *neighbors;
+        float *previous_best;
+        float *target;
+
+private:
+	// PSO Callbacks to functions
+	
+	FLEXT_CALLBACK_V(set_pop);
+	FLEXT_CALLBACK_V(set_particle);
+	FLEXT_CALLBACK_V(set_target);
+	FLEXT_CALLBACK_FF(rand_pop); 
+	FLEXT_CALLBACK_F(optim_thresh);
+	FLEXT_CALLBACK(iterate);
+	FLEXT_CALLBACK(reset);
+	FLEXT_CALLBACK(m_help);
+};
+
+// instantiate the class
+FLEXT_NEW_3("pso",pso, int,int,int)
+
+
+pso::pso(int Popsize, int Dimen, int HoodSize)
+{ 
+	// Say hello
+	post("--------------------------------------------\nParticle Swarm Optimizer (PSO)\nCopyright Ben Bogart 2003.\nBased on code by Thomas Grill & Jim Kennedy.\n--------------------------------------------");
+
+	// var defines
+	int i,j,k;
+
+	// default vars
+	this->Min = 0;
+        this->Max = 1;
+	this->optimization_threshold = 5;
+
+        // Copy Arguments to the class variables
+        this->popsize = Popsize;
+        this->dimen = Dimen;
+        this->hoodsize = HoodSize;
+
+        // Create particle Arrays (single dimensional!)
+        this->current_position = new float[this->popsize*this->dimen];
+        this->velocity = new float[this->popsize*this->dimen];
+        this->previous_best_position = new float[this->popsize*this->dimen];
+        this->neighbors = new int[this->popsize*this->hoodsize];
+        this->previous_best = new float[this->popsize];
+
+        // Create target array
+        this->target = new float[this->dimen];
+
+	// define inlets:
+	// first inlet must always by of type anything (or signal for dsp objects)
+	AddInAnything();  // add one inlet for any message
+	
+	// define outlets:
+	AddOutList("Particle positions.");
+	AddOutFloat("Current minimization.");
+	AddOutBang("Bang when minimization has been reached.");
+	
+	// register methods
+	FLEXT_ADDMETHOD_(0,"set_pop",set_pop);
+	FLEXT_ADDMETHOD_(0,"set_part", set_particle);
+	FLEXT_ADDMETHOD_FF(0,"rand_pop",rand_pop);
+	FLEXT_ADDMETHOD_F(0,"optimization_threshold", optim_thresh);
+	FLEXT_ADDBANG(0,iterate);
+	FLEXT_ADDMETHOD_(0,"reset",reset);
+	FLEXT_ADDMETHOD_(0,"help",m_help);
+	FLEXT_ADDMETHOD_(0,"target",set_target);
+
+	// init pso
+	pso::init();
+} 
+
+float pso::minimize(int particle)
+{
+	float result=0;
+	int d;
+
+	for (d=0; d< this->dimen; d++)
+	{
+	        // Pythagoras - c^2=(a^2+b^2) - for each dimension!! 
+		result += pow( this->current_position[particle*this->dimen+d]-(float)this->target[d],2);
+	}
+
+	return result;
+}
+
+void pso::copy_positions()
+{
+	int p,d;
+
+	// For each particle and each dimension
+        for (p=0; p< this->popsize; p++)
+        {
+          for (d=0; d< this->dimen; d++)
+          {
+                this->previous_best_position[p*this->dimen+d] = this->current_position[p*this->dimen+d];
+          }
+        }
+}
+
+// Deconstructor
+pso::~pso()
+{
+	// Remove Arrays from memmory space
+        delete[] this->current_position;
+        delete[] this->velocity;
+        delete[] this->previous_best_position;
+        delete[] this->neighbors;
+        delete[] this->previous_best;
+        delete[] this->target;
+}
+
+// The population must be set before this function is run!
+void pso::init()
+{
+	int p,n;
+
+	// Do stuff for random # generator
+	time_t timer = time(NULL);
+	srand((unsigned)timer);
+
+	// set initial population
+	pso::rand_vel();
+	pso::copy_positions();
+
+	// For each particle
+	for (p=0; p< this->popsize; p++)
+	{
+		// Who has the best solutions?
+		this->previous_best[p]=pso::minimize(p);
+
+		// Create neighborhood topology
+		for (n=0; n< this->hoodsize; n++)
+		{
+       			/* Connect each neighbor to its previous and next particle */
+        		this->neighbors[p*this->hoodsize+n]=p-1+n;
+
+        		/* Make a ring so the first and last particles are connected */
+        		if(this->neighbors[p*this->hoodsize+n] < 0)
+        		{
+          		  this->neighbors[p*this->hoodsize+n]=this->popsize-this->neighbors[p*this->hoodsize+n]-2;
+        		} else if(this->neighbors[p*this->hoodsize+n] >= this->popsize)
+        		{
+          	 	  this->neighbors[p*this->hoodsize+n]=this->neighbors[p*this->hoodsize+n]-this->popsize;
+        		} 
+		}
+	}
+
+	// Set initial global best solution
+	this->gbest=0;
+}
+
+void pso::set_pop(int argc,t_atom *argv)
+{
+        int i;
+
+        // If the number of arguments matches the number of particles*dimensions
+        if (argc == this->dimen*this->popsize )
+        {
+                for (i=0; i< this->dimen*this->popsize; i++)
+                {
+                        this->current_position[i] = GetFloat(argv[i]);
+                }
+                post("%s: Population Set.", thisName() );
+        } else {
+                post("%s: There must be %d arguments for each of the %d particles.\n     You entered %d/%d arguments.", thisName(), this->dimen, this->popsize, argc, this->dimen*this->popsize);
+        }
+
+	// Do init stuff again
+	pso::copy_positions();
+
+	// Send out new values
+	pso::output_positions();
+}
+
+void pso::set_particle(int argc,t_atom *argv)
+{
+        int i,particle,in,out;
+
+        // If the number of arguments matches the number of dimensions plus the index value
+        if ( argc == this->dimen+1 )
+        {
+		// Which particle are we setting?
+		// Check to make sure the particle <= this->popsize
+		particle = GetAInt(argv[0]);
+
+		if (particle < this->popsize && particle >= 0)
+		{
+
+                	// Set particle
+			for (i=1; i< argc; i++)
+			{
+				this->current_position[particle*this->dimen+(i-1)] = GetAFloat(argv[i]);
+			}
+
+                	post("%s: Particle %d Set.", thisName(), particle);
+
+		        // Do init stuff again
+     			pso::copy_positions();
+
+        		// Send out new values
+        		pso::output_positions();
+
+		} else {
+			post("%s: The particle %d is not within the population limits of 0 to %d.", thisName(), particle, this->popsize-1);
+		}
+       	} else {
+                post("%s: There must be %d arguments for each particle.\n     You entered %d arguments.", thisName(), this->dimen, argc);
+        }
+}
+
+void pso::set_target(int argc,t_atom *argv)
+{
+	int i;
+
+	// If the number of arguments matches the number of dimensions
+	if (argc == this->dimen )
+	{
+		for (i=0; i<dimen; i++)
+		{
+			this->target[i] = GetFloat(argv[i]);
+		}
+		post("%s: Target Set.", thisName() );
+	} else {
+		post("%s: There must be one argument for each of the %d dimensions.\n     You entered %d arguments.", thisName(), this->dimen, argc);
+	}
+}
+
+void pso::optim_thresh(float threshold)
+{
+	this->optimization_threshold = threshold;
+	post("%s: Optimization Threshold set to %f.", thisName(), (threshold/100000000) );
+}
+
+void pso::rand_pop(float min, float max)
+{
+    // set the class variables to the min and max values
+    this->Min = min;
+    this->Max = max;
+
+    int p,d;
+
+    for(p = 0; p < this->popsize; p++)
+    {
+        for(d = 0; d < this->dimen; d++)
+	{
+	    // set to random numbers min-max
+            this->current_position[p*this->dimen+d] = ((float)rand()/RAND_MAX)*(max-min)+min;
+	}
+    }
+
+    pso::copy_positions();
+
+    post("%s: Population Randomized.", thisName() ); 
+
+    // Output new positions
+    pso::output_positions();
+}
+
+void pso::rand_vel()
+{ 
+    int p,d;
+    for(p = 0; p < this->popsize; p++)
+    {
+        for(d = 0; d < this->dimen; d++)
+        {
+	    // set to random numbers 0-1
+            this->velocity[p*this->dimen+d] = ((float)rand()/RAND_MAX);
+
+	    // Set a random number of the velocities to negative
+	    if ( ((float)rand()/RAND_MAX) < 0.5 )
+		this->velocity[p*this->dimen+d] = this->velocity[p*this->dimen+d]*-1;
+        }
+    }
+}
+
+void pso::iterate()
+{
+	int p,d,n,g,neighbor,index_p,index_g;
+	float current_minima,rand1,rand2;
+	
+        // Create constants
+        float khi=0.729;
+        float HalfPhi=2.05;
+
+	// For each particle
+	for (p=0; p< this->popsize; p++)
+	{
+	  // Who has the best solution?
+	  current_minima = pso::minimize(p);
+
+	  // Set initial neighbor with which to compare (first neighbor)
+	  // Changed this to fix segfault (from popsize to hoodsize)
+	  g=neighbors[p*this->hoodsize];
+
+	  // For each neighbor
+	  for (n=0; n< this->hoodsize; n++)
+	  {
+	    neighbor=this->neighbors[p*this->hoodsize+n];
+	    if (this->previous_best[neighbor] < this->previous_best[g])
+	    {
+
+		// If the current neighbor has a better solution then make g (the best neighbor) the current neighbor
+		g=neighbor; 
+	    }
+	    if (current_minima < this->previous_best[p])
+	    {
+		if (current_minima < this->previous_best[this->gbest])
+		{
+		  this->gbest = p;
+		}
+		for (d=0; d< this->dimen; d++)
+		{
+		  this->previous_best_position[p*this->dimen+d] = this->current_position[p*this->dimen+d];
+		}
+		this->previous_best[p]=current_minima;
+	    }
+
+	    for (d=0; d< this->dimen; d++)
+	    {
+		rand1 = (float)rand()/RAND_MAX;
+		rand2 = (float)rand()/RAND_MAX;
+
+		index_p = p*this->dimen+d;
+		index_g = g*this->dimen+d;
+
+		if ( (index_p < dimen*popsize && index_p >= 0) && (index_g < dimen*popsize && index_g >= 0) )
+		{
+			this->velocity[index_p]=khi*(this->velocity[index_p] + rand1*HalfPhi*(this->previous_best_position[index_p] - this->current_position[index_p]) + rand2*HalfPhi*(this->previous_best_position[index_g] - this->current_position[index_p]));
+            		this->current_position[index_p]=this->current_position[index_p]+this->velocity[index_p];
+		}
+	    }
+	  }
+	}
+
+	// Have we minimized yet?
+	// For Small systems (Nell) use 0.0000005
+	// This constant 0.0000005 is user specified add a method for it? Will be send enough digits of percision?
+	if (this->previous_best[this->gbest] <= (this->optimization_threshold/10000000))
+	{
+		// Send bang out the last outlet (numOutlets-1)
+		ToOutBang( CntOut()-1 );
+	}
+
+	// Output current minimization
+	ToOutFloat(1, this->previous_best[this->gbest]);
+
+	// Output the current position of the particles
+	pso::output_positions();
+}
+
+void pso::output_positions()
+{
+	int d,p,atoms;
+	t_atom atom;
+	t_atom p_atom;
+	AtomList list;
+
+	// Construct a list of particle positions for each dimension
+	for (p=0; p< this->popsize; p++)
+	{
+		// Clear the list first
+		list.Clear();
+	
+		// start the lists with the index of the particle
+		SetFloat(p_atom, (float)p );
+		list.Append(p_atom);
+
+		for (d=0; d< this->dimen; d++)
+		{
+			SetFloat(atom, this->current_position[p*this->dimen+d]);
+			list.Append(atom);
+		}
+
+		// Send out list
+		ToOutList(0, list);
+	}
+}
+
+// Population must be randomized or set FIRST!
+void pso::reset()
+{
+	// Reinitialize the PSO
+	pso::init();
+	post("%s: Reset.", thisName());
+}
+
+void pso::m_help()
+{
+	post("%s Help:", thisName());
+	post("Arguments: [Population Size] [Number of Dimensions] [Neighborhood Size]");
+	post("");
+
+	post("PSO Help Method:");
+	post("  'help'\t\t\t- This message.");
+	post("");
+
+	post("PSO Setup Methods:");
+	post("  'target [list]'\t\t- Specify the optimization target with list of values for each dimension.");
+	post("  'rand_pop [min] [max]'\t- Randomize the population with values ranging from min to max.");
+	post("  'set_pop [list]'\t\t- Set population with list of values for each particle for each dimension.");
+	post("  'set_part [particle] [list]'\t- Set particle with values for each dimension.");
+	post("  'optim_thresh [int]'\t\t- Set the threshold at which minimization is considered reached. (0-10)");
+	post("");
+
+	post("PSO Run-Time Methods:");
+	post("  'reset'\t\t\t- Reset the PSO.");
+	post("  bang\t\t\t\t- Calculate one interation of the PSO.");
+}
diff --git a/pso/makefile.pd-darwin b/pso/makefile.pd-darwin
new file mode 100644
index 0000000..47bcc48
--- /dev/null
+++ b/pso/makefile.pd-darwin
@@ -0,0 +1,78 @@
+# PSO - Particle Swarm Optimizer - Copyright Ben Bogart 2003
+# makefile adapted from pool - Copyright (c) 2002 Thomas Grill (xovo@gmx.net)
+#
+# Makefile for gcc @ darwin (OSX)
+#
+# usage:
+# to build run "make -f makefile.pd-darwin"
+# to install (as root), do "make -f makefile.pd-darwin install"
+#
+
+CONFIG=config-pd-darwin.txt
+
+include $(CONFIG)
+
+FLEXTLIB=$(FLEXTPATH)/flext.a
+
+# compiler+linker stuff	
+INCLUDES=$(PDPATH) 
+LIBPATH=
+FLAGS=-DFLEXT_SYS=2 
+CFLAGS=-O6 ${UFLAGS} -Wno-unused -Wno-parentheses -Wno-switch -Wstrict-prototypes
+LIBS=m
+LDFLAGS=-bundle -bundle_loader $(PD)
+FRAMEWORKS=Carbon
+
+
+# ---------------------------------------------
+# the rest can stay untouched
+# ----------------------------------------------
+
+NAME=pso
+
+# all the source files from the package
+SRCS=main.cpp pool.cpp data.cpp
+HDRS=pool.h
+
+DIR=.
+
+TARGET=$(TARGDIR)/$(NAME).pd_darwin
+
+# default target
+all: $(TARGDIR) $(TARGET)
+
+$(patsubst %,$(DIR)/%,$(SRCS)): $(patsubst %,$(DIR)/%,$(HDRS)) $(FLEXTLIB) $(CONFIG)
+	touch $@
+
+$(TARGDIR):
+	-mkdir $(TARGDIR)
+
+$(TARGDIR)/%.o : $(DIR)/%.cpp
+	$(CXX) -c $(CFLAGS) $(FLAGS) $(patsubst %,-I%,$(INCLUDES) $(FLEXTPATH)) $< -o $@
+
+$(TARGET) : $(patsubst %.cpp,$(TARGDIR)/%.o,$(SRCS)) $(FLEXTLIB) 
+	$(CXX) $(LDFLAGS) $^ $(patsubst %,-framework %,$(FRAMEWORKS)) $(patsubst %,-L%,$(LIBPATH)) $(patsubst %,-l%,$(LIBS)) -o $@ 
+	chmod 755 $@
+
+$(INSTPATH):
+	-mkdir $(INSTPATH)
+
+install:: $(INSTPATH)
+
+install:: $(TARGET)
+	cp $^ $(INSTPATH)
+#	chown root.root  $(patsubst %,$(INSTPATH)/%,$(notdir $^))
+#	chmod 755 $(patsubst %,$(INSTPATH)/%,$(notdir $^))
+
+.PHONY: clean
+clean:
+	rm -f $(TARGDIR)/*.o $(TARGET)
+	
+
+
+
+
+
+
+
+
diff --git a/pso/makefile.pd-linux b/pso/makefile.pd-linux
new file mode 100644
index 0000000..aa6a721
--- /dev/null
+++ b/pso/makefile.pd-linux
@@ -0,0 +1,69 @@
+# PSO - Particle Swarm Optimizer - Copyright Ben Bogart 2003
+# makefile adapted from prepend - Copyright (c) 2002 Thomas Grill (xovo@gmx.net)
+#
+# Makefile for gcc 
+#
+# usage: make -f makefile.pd-linux
+#
+# ---------------------------------------------
+
+NAME=pso
+
+# where to build
+TARGDIR=./pd-linux
+
+# where to install	### EDIT! ###
+INSTDIR=
+
+# flext stuff  ### EDIT! ###
+FLEXTPATH=/usr/local/lib/pd/flext
+FLEXTLIB=$(FLEXTPATH)/flext.a
+
+# compiler+linker stuff	### EDIT! ###
+INCLUDES=/usr/lib/pd/include
+FLAGS=-DPD
+CFLAGS=-O6 -mcpu=pentium 
+LIBS=m
+
+
+# the rest can stay untouched
+# ----------------------------------------------
+
+# all the source files from the package
+SRCS=main.cpp 
+HDRS=
+
+TARGET=$(TARGDIR)/$(NAME).pd_linux
+
+# default target
+all: $(TARGDIR) $(TARGET)
+
+$(SRCS): $(HDRS)
+	touch $@
+
+$(TARGDIR):
+	mkdir $(TARGDIR)
+
+$(TARGDIR)/%.o : %.cpp
+	$(CXX) -c $(CFLAGS) $(FLAGS) $(patsubst %,-I%,$(INCLUDES) $(FLEXTPATH)) $< -o $@
+
+$(TARGET) : $(patsubst %.cpp,$(TARGDIR)/%.o,$(SRCS)) $(FLEXTLIB) 
+	$(CXX) $(LDFLAGS) -shared $^ $(patsubst %,-l%,$(LIBS)) -o $@ 
+	chmod 755 $@
+
+$(INSTDIR):
+	mkdir $(INSTDIR)
+
+install:: $(INSTDIR)
+
+install:: $(TARGET)  
+	cp $^ $(INSTDIR)
+	chown root.root $(patsubst %,$(INSTDIR)/%,$(notdir $^))
+
+.PHONY: clean
+clean:
+	rm -f $(TARGDIR)/*.o $(TARGET)
+	
+
+
+