Logo
Distributed Genetic Programming Framework
print print

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

Here you can find all the information about the file org.dgpf.search.api.p2p.P2PParameters.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:57:13
 * Original Filename: org.dgpf.search.api.p2p.P2PParameters.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 org.dgpf.search.api.SearchUtils;
import org.sfc.math.stochastic.Randomizer;
import org.sfc.meta.MetaInformation;

/**
 * This class is a <code>SearchParameters</code>-extension for all search
 * algorithm distribution schemes that cooperate using the search p2p node.
 *
 * @author Thomas Weise
 */

public class P2PParameters extends P2PData
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  

/**
 * The p2p parameters meta infomation.
 */

  public  static  final MetaInformation P2P_PARAMETERS_METAINFO ;
  
  static
    {
    ALLOWED_EMIGRANTS.add_port(P2PParameters.class, true, true, null);
    ALLOWED_IMMIGRANTS.add_port(P2PParameters.class, true, true, null);  
    CHALLENGE_IMMIGRANTS.add_port(P2PParameters.class, true, true, null);    
    EMIGRATE_BEST.add_port(P2PParameters.class, true, true, null);    
    IMMIGRATION_BY_LEVEL.add_port(P2PParameters.class, true, true, null);
    IMMIGRATION_THRESHOLD.add_port(P2PParameters.class, true, true,
                                   SearchUtils.FITNESS_FUNCTION_COUNT_FUNC);
    
    P2P_PARAMETERS_METAINFO = new MetaInformation();
    }
  
/**
 * Create a new p2p parameter set.
 * @param p_ff_count  The count of fitness functions evaluated by this
 *                    search.
 */

  public  P2PParameters(int p_ff_count)
    {
    super(p_ff_count);
    }
  


/**
 * 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.
 */

  @Override
  public  void  set_allowed_immigrants  (final int p_allowed_immigrants)
    {
    super.set_allowed_immigrants(p_allowed_immigrants);
    }
  
  
/**
 * 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.
 */

  @Override
  public  void  set_allowed_emigrants  (final int p_allowed_emigrants)
    {
    super.set_allowed_emigrants(p_allowed_emigrants);
    }
  

/**
 * 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.
 */

  @Override
  public  void  set_emigrate_best  (final boolean p_emigrate)
    {
    super.set_emigrate_best(p_emigrate);
    }



/**
 * <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.
 */

  @Override
  public  void  set_immigration_threshold(final int    p_ff_index,
                                          final double p_value)
    {
    super.set_immigration_threshold(p_ff_index, p_value);
    }



/**
 * 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.
 */

  @Override
  public  void  set_challenge_immigrants  (final boolean p_challenge)
    {
    super.set_challenge_immigrants(p_challenge);
    }
  
  
/**
 * 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. 
 */

  @Override
  public  void  set_immigration_by_level (final boolean p_by_level)
    {
    super.set_immigration_by_level(p_by_level);
    }

/**
 * This method is called to inform the p2p-parameters that a new strategy
 * is working on it. This method is especially needed when serializing and
 * deserializing.
 * @param p_strategy  The new p2p adaptation strategy working on this
 *                    parameter set.
 */

  public final void notify_strategy(final P2PAdaptationStrategy p_strategy)
    {
    if(p_strategy instanceof StatefulP2PAdaptationStrategy)
      {
      ((StatefulP2PAdaptationStrategy)p_strategy).m_parameters = this;
      }
    }
  
 
/**
 * After setting the non-fitness-influencing parameters of this search
 * parameter set to the allowed maximum, call this method to alter the
 * configuration randomly.
 * @param p_r The randomizer to be used.
 */

  public  void  configure_randomly  (final Randomizer p_r)
    {  
    this.set_allowed_emigrants(p_r.nextInt(this.get_allowed_emigrants())+1);
    this.set_allowed_immigrants(p_r.nextInt(
                               this.get_allowed_immigrants())+1);
    this.set_challenge_immigrants(p_r.nextBoolean());
    this.set_emigrate_best(p_r.nextBoolean());
    }
  }

File Information:

file name:P2PParameters.java
package:org.dgpf.search.api.p2p
qualified name:org.dgpf.search.api.p2p.P2PParameters.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/dgpf/search/api/p2p/P2PParameters.java
size:6.866 KB (7031 B)
uploaded: 2015-07-22 04:11:00 GMT+0000
last update: 2006-08-22 13:24:59 GMT+0000
last access: 2017-11-20 02:12:41 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 02:12:41 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo