evocommon.h

//---------------------------------------------------------------------
//  Algorithmic Conjurings @ http://www.coyotegulch.com
//  Evocosm -- An Object-Oriented Framework for Evolutionary Algorithms
//
//  evocommon.h
//---------------------------------------------------------------------
//
//  Copyright 1996, 1999, 2002, 2003, 2004, 2005, 2006, 2007 Scott Robert Ladd
//
//  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.
//
//-----------------------------------------------------------------------
//
//  For more information on this software package, please visit
//  Scott's web site, Coyote Gulch Productions, at:
//
//      http://www.coyotegulch.com
//
//-----------------------------------------------------------------------

#if !defined(LIBEVOCOSM_EVOGLOBAL_H)
#define LIBEVOCOSM_EVOGLOBAL_H

// Brahe library
#if defined(_MSC_VER)
#include "prng.h"
#else
#include "libbrahe/prng.h"
#endif

// Standard C++ Library
#include <string>
#include <iostream>
#include <iomanip>

#if !defined(_MSC_VER)
#include <unistd.h>
#endif
// Windows
#if defined(_MSC_VER)
#include "windows.h"
#undef max
#undef min
#endif

namespace libevocosm
{

    class prng
    {
    private:
        brahe_prng_state_t m_random;

    public:
        prng()
        {
            brahe_prng_init(&m_random,BRAHE_PRNG_MWC1038,0);
        }

        ~prng()
        {
            brahe_prng_free(&m_random);
        }

        void set_seed(uint32_t a_seed)
        {
            brahe_prng_init(&m_random,BRAHE_PRNG_MWC1038,a_seed);
        }

        uint32_t get_seed()
        {
            return m_random.m_seed;
        }

        size_t get_index(size_t n)
        {
            return brahe_prng_index(&m_random,n);
        }

        double get_real()
        {
            return brahe_prng_real2(&m_random);
        }
    };


    class globals
    {
    protected:
        static size_t rand_index(size_t n)
        {
            return g_random.get_index(n);
        }

        static prng g_random;

        static std::string g_version;

    public:
        static void set_random_seed(uint32_t a_seed)
        {
            g_random.set_seed(a_seed);
        }

        static uint32_t get_seed()
        {
            return g_random.get_seed();
        }

        static std::string version()
        {
            return g_version;
        }
    };


    class listener
    {
        public:

            virtual void ping_generation_begin(size_t a_generation_number) = 0;


            virtual void ping_generation_end(size_t a_generation_number) = 0;


            virtual void ping_population_begin(size_t a_population_number) = 0;


            virtual void ping_population_end(size_t a_population_number) = 0;


            virtual void ping_fitness_test_begin(size_t a_organism_number) = 0;


            virtual void ping_fitness_test_end(size_t a_organism_number) = 0;


            virtual void report(const std::string & a_text) = 0;


            virtual void report_error(const std::string & a_text) = 0;


            virtual void run_complete() = 0;


            virtual void yield() = 0;
    };


    class null_listener : public listener
    {
        public:

            virtual void ping_generation_begin(size_t a_generation_number)
            {
                // do nothing
            }


            virtual void ping_generation_end(size_t a_generation_number)
            {
                // do nothing
            }


            virtual void ping_population_begin(size_t a_population_number)
            {
                // do nothing
            }


            virtual void ping_population_end(size_t a_population_number)
            {
                // do nothing
            }


            virtual void ping_fitness_test_begin(size_t a_organism_number)
            {
                // do nothing
            }


            virtual void ping_fitness_test_end(size_t a_organism_number)
            {
                // do nothing
            }


            virtual void report(const std::string & a_text)
            {
                // do nothing
            }


            virtual void report_error(const std::string & a_text)
            {
                // do nothing
            }


            virtual void run_complete()
            {
                // do nothing
            }


            virtual void yield()
            {
                // do nothing
            }
    };


    class listener_stdout : public listener
    {
        public:

            virtual void ping_generation_begin(size_t a_generation_number)
            {
                std::cout << "------------------------------------------------------------\ngeneration "
                          << a_generation_number << " begins" << std::endl;
            }


            virtual void ping_generation_end(size_t a_generation_number)
            {
                // nada
            }


            virtual void ping_population_begin(size_t a_population_number)
            {
                std::cout << "\npopulation " << std::setw(2) << a_population_number << ": " << std::flush;
            }


            virtual void ping_population_end(size_t a_population_number)
            {
                // nada
            }


            virtual void ping_fitness_test_begin(size_t a_organism_number)
            {
                // nada
            }


            virtual void ping_fitness_test_end(size_t a_organism_number)
            {
                std::cout << "." << std::flush;
            }


            virtual void report(const std::string & a_text)
            {
                std::cout << a_text;
            }


            virtual void report_error(const std::string & a_text)
            {
                std::cerr << a_text;
            }


            virtual void run_complete()
            {
                // nada
            }


            virtual void yield()
            {
#if defined(_MSC_VER)
                Sleep(50000);
#else
                usleep(50000);
#endif
            }
    };

}

#endif