GA1DBinStrGenome.h

/* ----------------------------------------------------------------------------
  mbwall 19apr95
  Copyright (c) 1995 Massachusetts Institute of Technology
                     all rights reserved
---------------------------------------------------------------------------- */
 
#pragma once
 
#include "GABinStr.hpp"
#include "GAGenome.h"
 
/* ----------------------------------------------------------------------------
1DBinaryStringGenome
-------------------------------------------------------------------------------
resize
    These genomes are resizable.  In addition, you can set a resize behaviour
  to specify the bounds in which the resize can occur.
 
copy
    Copy bits from the specified genome using the location and length
  that are passed to us.  If the current genome is too short for the
  entire length, copy whatever we can.  If the original genome is too
  short for the specified length, copy whatever we can.  If either location
  is out of bounds, return without doing anything.
    We do NOT check for negative values in the locations!
    This routine clips if the copy sizes do not match - it does NOT resize the
  genome to fit the copy.  You'll have to do resizes before you call this
  routine if you want the copy to fit the original.
 
==, !=
    Are two genomes equal?  Our test for equality is based upon the
  contents of the genome, NOT the behaviour.  So as long as the bitstreams
  match, the genomes are 'equal'.  This means that a resizeable genome
  may be equal to a fixed-length genome.  But a chromsome with 500
  bits allocated is not equal to a genome with 10 bits allocated unless
  both are the same size.
---------------------------------------------------------------------------- */
 
class GA1DBinaryStringGenome : public GABinaryString, public GAGenome
{
  public:
    GADefineIdentity("GA1DBinaryStringGenome", GAID::BinaryStringGenome);
 
    static void UniformInitializer(GAGenome &);
    static void UnsetInitializer(GAGenome &);
    static void SetInitializer(GAGenome &);
    static int FlipMutator(GAGenome &, float);
    static int UniformCrossover(const GAGenome &, const GAGenome &, GAGenome *, GAGenome *);
    static int EvenOddCrossover(const GAGenome &, const GAGenome &, GAGenome *, GAGenome *);
    static int OnePointCrossover(const GAGenome &, const GAGenome &, GAGenome *, GAGenome *);
    static int TwoPointCrossover(const GAGenome &, const GAGenome &, GAGenome *, GAGenome *);
    static float BitComparator(const GAGenome &, const GAGenome &);
 
  public:
    explicit GA1DBinaryStringGenome(unsigned int len, GAGenome::Evaluator f = nullptr, void *u = nullptr);
    GA1DBinaryStringGenome(const GA1DBinaryStringGenome &orig);
    GA1DBinaryStringGenome &operator=(const GAGenome &arg)
    {
        copy(arg);
        return *this;
    }
    GA1DBinaryStringGenome &operator=(const short array[]) // no err checks!
    {
        for (unsigned int i = 0; i < data.size(); i++)
        {
            gene(i, *(array + i));
        }
        return *this;
    }
    GA1DBinaryStringGenome &operator=(const int array[]) // no err checks!
    {
        for (unsigned int i = 0; i < data.size(); i++)
        {
            gene(i, *(array + i));
        }
        return *this;
    }
    ~GA1DBinaryStringGenome() override;
    GAGenome *clone(GAGenome::CloneMethod flag = CloneMethod::CONTENTS) const override;
    void copy(const GAGenome &) override;
 
    int read(std::istream &is) override;
    int write(std::ostream &os) const override;
 
    bool equal(const GAGenome &c) const override;
 
    short gene(unsigned int x = 0) const { return bit(x); }
    short gene(unsigned int x, short value)
    {
        _evaluated = false;
        return ((bit(x) == value) ? value : bit(x, value));
    }
    short operator[](unsigned int x) { return gene(x); }
    int length() const { return nx; }
    int length(int x)
    {
        resize(x);
        return nx;
    }
    int resize(int l);
    int resizeBehaviour() const;
    int resizeBehaviour(unsigned int lower, unsigned int upper);
    void copy(const GA1DBinaryStringGenome &orig, unsigned int r,
              unsigned int x, unsigned int length);
    bool equal(const GA1DBinaryStringGenome &orig, unsigned int r,
              unsigned int x, unsigned int length) const;
    void set(unsigned int x, unsigned int length);
    void unset(unsigned int x, unsigned int length);
    void randomize(unsigned int x, unsigned int length);
    void randomize() { GABinaryString::randomize(); }
    void move(unsigned int destx, unsigned int srcx, unsigned int length);
 
  protected:
    unsigned int nx; // how long is the data string?
    unsigned int minX; // what is the lower limit?
    unsigned int maxX; // what is the upper limit?
};
 
inline void GA1DBinaryStringGenome::copy(const GA1DBinaryStringGenome &orig,
                                         unsigned int r, unsigned int x,
                                         unsigned int l)
{
    if (l > 0 && x < orig.nx && r < nx)
    {
        if (x + l > orig.nx)
        {
            l = orig.nx - x;
        }
        if (r + l > nx)
        {
            l = nx - r;
        }
        GABinaryString::copy(orig, r, x, l);
    }
    _evaluated = false;
}
inline void GA1DBinaryStringGenome::set(unsigned int x, unsigned int l)
{
    if (x + l > nx)
    {
        l = nx - x;
    }
    GABinaryString::set(x, l);
    _evaluated = false;
}
inline void GA1DBinaryStringGenome::unset(unsigned int x, unsigned int l)
{
    if (x + l > nx)
    {
        l = nx - x;
    }
    GABinaryString::unset(x, l);
    _evaluated = false;
}
inline void GA1DBinaryStringGenome::randomize(unsigned int x, unsigned int l)
{
    if (x + l > nx)
    {
        l = nx - x;
    }
    GABinaryString::randomize(x, l);
    _evaluated = false;
}
inline void GA1DBinaryStringGenome::move(unsigned int x, unsigned int srcx,
                                         unsigned int l)
{
    if (srcx + l > nx)
    {
        l = nx - srcx;
    }
    if (x + l > nx)
    {
        l = nx - x;
    }
    GABinaryString::move(x, srcx, l);
    _evaluated = false;
}