Logo
Distributed Genetic Programming Framework
print print

File org.dgpf.search.api.p2p.P2PData.java

Here you can find all the information about the file org.dgpf.search.api.p2p.P2PData.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-04-26 04:38:54
 * Original Filename: org.dgpf.search.api.p2p.P2PData.java
 * Version          : 2.0.1
 * Last modification: 2006-05-28
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.dgpf.search.api.p2p;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import org.dgpf.search.api.SearchUtils;
import org.sfc.meta.BoundedDoubleProperty;
import org.sfc.meta.BoundedIntProperty;
import org.sfc.meta.MetaInformation;
import org.sfc.meta.Property;
import org.sfc.utils.ICloneable;
import org.sfc.utils.Typesafe;

/**
 * This internal data set is the base class for the p2p parameters and the
 * p2p state. It defines prototypes of the variables needed.
 *
 * @author Thomas Weise
 */

public  class P2PData implements  Serializable, ICloneable
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;

/**
 * The p2p data meta infomation.
 */

  public  static  final MetaInformation P2P_DATA_METAINFO ;
  

/**
 * The property for the count of allowed emigrants.
 */

  public  static  final BoundedIntProperty    ALLOWED_EMIGRANTS ;
/**
 * The property for the count of allowed immigrants.
 */

  public  static  final BoundedIntProperty    ALLOWED_IMMIGRANTS ;
/**
 * The property telling if immigrants have to challenge
 * locals before being integrated into the search.
 */

  public  static  final Property<Boolean>     CHALLENGE_IMMIGRANTS ;
/**
 * The property telling whether the best known individual
 * will additionally always be emigrated.
 */

  public  static  final Property<Boolean>     EMIGRATE_BEST ;  
/**
 * The property telling whetherthe immigrant thresholds
 * will only be applied to individuals comming from a higher update level.
 */

  public  static  final Property<Boolean>     IMMIGRATION_BY_LEVEL  ;
/**
 * The property for the immigration thresholds per fitness
 * functions.
 */

  public  static  final BoundedDoubleProperty IMMIGRATION_THRESHOLD ; 
  
  static
    {
    ALLOWED_EMIGRANTS = new BoundedIntProperty("allowed_emigrants",
                             P2PSearchUtils.DISTRIBUTION_CONTROL_PROPERTIES,
                             0, SearchUtils.DEFAULT_MAX_INT);
    ALLOWED_EMIGRANTS.add_port(P2PData.class, true, false, null);

    ALLOWED_IMMIGRANTS = new BoundedIntProperty("allowed_immigrants",
                             P2PSearchUtils.DISTRIBUTION_CONTROL_PROPERTIES,
                             0, SearchUtils.DEFAULT_MAX_INT);
    ALLOWED_IMMIGRANTS.add_port(P2PData.class, true, false, null);
  
    CHALLENGE_IMMIGRANTS = new Property<Boolean>("challenge_immigrants",
                             P2PSearchUtils.DISTRIBUTION_CONTROL_PROPERTIES,
                             boolean.class);
    CHALLENGE_IMMIGRANTS.add_port(P2PData.class, true, false, null);
    
    EMIGRATE_BEST = new Property<Boolean>("emigrate_best",
                             P2PSearchUtils.DISTRIBUTION_CONTROL_PROPERTIES,
                             boolean.class);
    EMIGRATE_BEST.add_port(P2PData.class, true, false, null);
    
    IMMIGRATION_BY_LEVEL = new Property<Boolean>("immigration_by_level",
                             P2PSearchUtils.DISTRIBUTION_CONTROL_PROPERTIES,
                             boolean.class);
    IMMIGRATION_BY_LEVEL.add_port(P2PData.class, true, false, null);
    
    IMMIGRATION_THRESHOLD = new BoundedDoubleProperty("immigration_threshold",
                             P2PSearchUtils.DISTRIBUTION_CONTROL_PROPERTIES,
                             0.0d, Double.MAX_VALUE);
    IMMIGRATION_THRESHOLD.add_port(P2PData.class, true, false,
                                   SearchUtils.FITNESS_FUNCTION_COUNT_FUNC);
    
    P2P_DATA_METAINFO = new MetaInformation();
    }
  
/**
 * <code>true</code> if and only if the best individual should always
 * be emigrated, regardless of all other factors.
 * @see #get_emigrate_best()
 */

  private           boolean               m_emigrate_best  ;
/**
 * If this value is <code>true</code>, the immigrants must compete against
 * the local population in order to immigrate. If the parameter is
 * <code>false</code>, the individuals may immigrate directly by straight
 * killing the locals.
 * @see #get_challenge_immigrants()
 */

  private           boolean               m_challenge_immigrants  ;
/**
 * Thresholds for immigration: immigrants may only enter if they have
 * fitnesses that are weaker than all the values specified here.
 * @see #get_immigration_threshold(int)
 */

  private transient double[]              m_immigration_th  ;
/**
 * If this parameter is <code>true</code>, the immigration thresholds will
 * only be applied if the update level (update) of their source search
 * engine is higher as the one of the current engine (+/- 10%).
 * @see #get_immigration_by_level()
 */

  private           boolean               m_immigration_by_level  ;
/**
 * The count of immigrants allowed to enter the queue.
 * @see #get_allowed_immigrants()
 */

  private           int                   m_allowed_immigrants  ;
/**
 * The count of emigrants allowed to enter the queue.
 * @see #get_allowed_emigrants()
 */

  private           int                   m_allowed_emigrants  ;
  
/**
 * Create a new p2p data record.
 * @param p_ff_count  The count of fitness functions evaluated by this
 *                    search.
 */

  P2PData(int p_ff_count)
    {
    super();

    double[]            l_d;

    this.m_immigration_th = l_d = new double[p_ff_count];

    for(--p_ff_count; p_ff_count >= 0; p_ff_count--)
      {
      l_d[p_ff_count] = Double.POSITIVE_INFINITY;
      }

    this.set_challenge_immigrants(P2PSearchUtils.DEFAULT_CHALLENGE_IMMIGRANTS);
    this.set_emigrate_best(P2PSearchUtils.DEFAULT_EMIGRATE_BEST);
    this.set_allowed_emigrants(P2PSearchUtils.DEFAULT_ALLOWED_EMIGRANTS);
    this.set_allowed_immigrants(P2PSearchUtils.DEFAULT_ALLOWED_IMMIGRANTS);
    this.set_immigration_by_level(P2PSearchUtils.DEFAULT_IMMIGRATION_BY_LEVEL);
    }

  
/**
 * Obtain the count of fitness functions.
 * @return The count of fitness functions.
 */

  public  final int get_fitness_function_count()
    {
    return this.m_immigration_th.length;
    }
  
/**
 * Obtain the count of immigrants allowed to be stored in the incomming
 * buffer at max.
 * @return The count of immigrants allowed to be stored in the incomming
 *         buffer at max.
 */

  public  final int get_allowed_immigrants()
    {
    return this.m_allowed_immigrants;
    }

/**
 * Set the count of immigrants allowed to be stored in the incomming
 * buffer at max.
 * @param p_allowed_immigrants  The count of immigrants allowed to be
 *                              stored in the incomming buffer at max.
 */

  void  set_allowed_immigrants  (final int p_allowed_immigrants)
    {
    if(p_allowed_immigrants >= 0)
      {
      this.m_allowed_immigrants = p_allowed_immigrants;
      }
    }
  
  
/**
 * Obtain the count of emigrants allowed to be stored in the incomming
 * buffer at max.
 * @return The count of emigrants allowed to be stored in the incomming
 *         buffer at max.
 */

  public  final int get_allowed_emigrants()
    {
    return this.m_allowed_emigrants;
    }

/**
 * Set the count of emigrants allowed to be stored in the incomming
 * buffer at max.
 * @param p_allowed_emigrants  The count of emigrants allowed to be
 *                              stored in the incomming buffer at max.
 */

  void  set_allowed_emigrants  (final int p_allowed_emigrants)
    {
    if(p_allowed_emigrants >= 0)
      {
      this.m_allowed_emigrants = p_allowed_emigrants;
      }
    }
  
/**
 * Returns <code>true</code> if and only if the best individual should
 * always be emigrated, regardless of all other factors.
 * @return <code>true</code> if and only if the best individual should
 *         always be emigrated, regardless of all other factors.
 */

  public  final boolean get_emigrate_best  ()
    {
    return this.m_emigrate_best;
    }

/**
 * Set wether the best individual of a update should always be tried
 * to emigrate.
 * @param p_emigrate <code>true</code> if and only if the best individual
 *                    should always be emigrated, regardless of all other
 *                    factors.
 */

  void  set_emigrate_best  (final boolean p_emigrate)
    {
    this.m_emigrate_best = p_emigrate;
    }



/**
 * <p>
 * Thresholds for immigration: immigrants may only enter if they have
 * fitnesses that are weaker than all the values specified here. For each
 * fitness function, there can one threshold value be defined denying all
 * immigrants with fitnesses above this value immigration. To disable this
 * threshold, <code>Double.POSITIVE_INFINITY</code> can be specified.
 * </p><p>
 * You may use this property to protect the local evolution from external
 * influences.</p>
 * @param p_ff_index  The index of the fitness function of concern.
 * @return  The immigration threshold for this fitness function.
 */

  public  final double  get_immigration_threshold(final int p_ff_index)
    {
    return this.m_immigration_th[p_ff_index];
    }

/**
 * <p>
 * Set the immigration threshold for the specified fitness function.
 * </p>
 * <p>
 * Thresholds for immigration: immigrants may only enter if they have
 * fitnesses that are weaker than all the values specified here. For each
 * fitness function, there can one threshold value be defined denying all
 * immigrants with fitnesses above this value immigration. To disable this
 * threshold, <code>Double.POSITIVE_INFINITY</code> can be specified.
 * </p><p>
 * You may use this property to protect the local evolution from external
 * influences.</p>
 *
 * @param p_ff_index  The index of the fitness function of concern.
 * @param p_value     The new immigration threshold for this fitness
 *                    function.
 */

  void  set_immigration_threshold(final int    p_ff_index,
                                  final double p_value)
    {
    if(p_value >= 0.0d)
      {
      this.m_immigration_th[p_ff_index] = p_value;
      }
    }

/**
 * If this value is <code>true</code>, the immigrants must compete against
 * the local population in order to immigrate. If the parameter is
 * <code>false</code>, the individuals may immigrate directly by straight
 * killing the locals.
 * @return  <code>true</code> if and only if newly arriving immigrants have
 *          to challenge the locals, <code>false</code> if the override the
 *          worst locals automatically.
 */

  public  final boolean get_challenge_immigrants()
    {
    return this.m_challenge_immigrants;
    }


/**
 * Set whether immigrants newly arriving have to challange the local peps
 * in order to survive or not.
 * @param p_challenge <code>true</code> if and only if newly arriving
 *                    immigrants have to challenge the locals,
 *                    <code>false</code> if the override the worst locals
 *                    automatically.
 */

  void  set_challenge_immigrants  (final boolean p_challenge)
    {
    this.m_challenge_immigrants = p_challenge;
    }
  

/**
 * If this parameter is <code>true</code>, the immigration thresholds will
 * only be applied if the update level (update) of their source search
 * engine is higher as the one of the current engine (+/- 10%).
 * @return <code>true</code> if the immigration thresholds should only be
 *         applied if the update level of the source is bigger than the
 *         own one. 
 */

  public  final boolean get_immigration_by_level()
    {
    return this.m_immigration_by_level;
    }
  
/**
 * If this parameter is set to <code>true</code>, the immigration
 * thresholds will only be applied if the update level (update) of
 * their source search engine is higher as the one of the current engine 
 * (+/- 10%).
 * @param p_by_level  <code>true</code> if the immigration thresholds
 *                    should only be applied if the update level of the
 *                    source is bigger than the own one. 
 */

  void  set_immigration_by_level (final boolean p_by_level)
    {
    this.m_immigration_by_level = p_by_level;
    }


/**
 * Assign the internal data of this search data to the data of
 * another one.
 * @param p_data  The simulation data  to assign to.
 */

  protected void  assign  (final P2PData p_data)
    {
    double[]  l_d;
    int       l_i;

    this.set_emigrate_best(p_data.m_emigrate_best);
    this.set_challenge_immigrants(p_data.m_challenge_immigrants);
    this.set_allowed_emigrants(p_data.m_allowed_emigrants);
    this.set_allowed_immigrants(p_data.m_allowed_immigrants);
    
    l_d = p_data.m_immigration_th;
    for(l_i = (l_d.length-1); l_i >= 0; l_i--)
      {
      this.set_immigration_threshold(l_i, l_d[l_i]);
      }
    this.set_immigration_by_level(p_data.get_immigration_by_level());
    }


/**
 * Stores the <code>SfcEvent</code> into the stream.
 * @param p_s The output stream.
 * @throws  IOException If something io-like went wrong.
 */

  private final void writeObject(final ObjectOutputStream p_s)
        throws IOException
    {
    p_s.defaultWriteObject();
    p_s.writeUnshared(this.m_immigration_th);
    }



/**
 * Reconstitute the <code>SfcEvent</code> instance from a stream (that is,
 * deserialize it).
 * @param p_s The input stream.
 * @throws  IOException If something io-like went wrong.
 * @throws  ClassNotFoundException  If a needed class could not be found.
 */

  private final void readObject(final ObjectInputStream p_s)
        throws IOException, ClassNotFoundException
    {
    p_s.defaultReadObject();
    this.m_immigration_th = ((double[])(p_s.readUnshared()));
    }  

/**
 * Perform the assign operation.
 * @param p_dest  The destination object to be assigned.
 * @param p_source The source object to assign from.
 */

  protected static  final void  do_assign(final P2PData  p_dest,
                                          final P2PData  p_source)
    {
    p_dest.assign(p_source);
    }
  
/**
 * Creates and returns a copy of this object.  The precise meaning 
 * of "copy" may depend on the class of the object. 
 *
 * @return     A clone of this instance.
 * 
 * @see java.lang.Cloneable
 */

  @Override
  public  Object  clone ()
    {
    P2PData l_d;
    
    try
      {
      l_d = Typesafe.cast(super.clone());
      }
    catch(Throwable l_t)
      {
      l_d = this;
      }
    
    l_d.m_immigration_th = l_d.m_immigration_th.clone();
    
    return l_d;
    }
  }

File Information:

file name:P2PData.java
package:org.dgpf.search.api.p2p
qualified name:org.dgpf.search.api.p2p.P2PData.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/search/api/p2p/P2PData.java
size:15.482 KB (15854 B)
uploaded: 2015-07-22 04:11:00 GMT+0000
last update: 2006-07-21 12:29:46 GMT+0000
last access: 2017-11-20 18:57:58 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2017-11-20 18:57:58 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo