option.cpp

模糊聚類分析源碼。包含教學文件

/*
  
  Context       : Fuzzy Clustering Algorithms

  Author        : Frank Hoeppner, see also AUTHORS file 

  Description   : implementation of class module Option
                  
  History       :
    

  Comment       : 
    This file was generated automatically. DO NOT EDIT.

  Copyright     : Copyright (C) 1999-2000 Frank Hoeppner

    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
*/
/*
  The University of Applied Sciences Oldenburg/Ostfriesland/Wilhelmshaven
  hereby disclaims all copyright interests in the program package `fc' 
  (tool package for fuzzy cluster analysis) written by Frank Hoeppner.
  
  Prof. Haass, President of Vice, 2000-Mar-10
*/

#ifndef Option_SOURCE
#define Option_SOURCE

/* configuration include */
#ifdef HAVE_CONFIG_H
/*
//FILETREE_IFDEF HAVE_CONFIG_H
*/
#include "config.h"
/*
//FILETREE_ENDIF
*/
#endif



// necessary includes
#include "Option.hpp"
#include "strconv-s.hpp"
#include "ustream-s.hpp"

// data
keyword_entry g_keyword_init[] =
  {{ "AUTO",FC_INIT_AUTO }
  ,{ "MEMB",FC_INIT_MEMB }
  ,{ "PROT",FC_INIT_AUTO }
  ,{ NULL,0 } 
  };
keyword_entry g_keyword_output[] =
  {{ "ALL",FC_OUTPUT_ALL}
  ,{ "BUTLINK",FC_OUTPUT_ALL_BUT_LINKS}
  ,{ "DATA",FC_OUTPUT_OPTION|FC_OUTPUT_DATA }
  ,{ "LINK",FC_OUTPUT_LINKAGE }
  ,{ "OPT",FC_OUTPUT_OPTION }
  ,{ "PROT",FC_OUTPUT_OPTION|FC_OUTPUT_CLUSTER }
  ,{ "QUIET",FC_OUTPUT_QUIET}
  ,{ NULL,0 } 
  };
const char KEYWORD_OPTION_SELECTAXIS[AXIS_END][16] = { "(select-x-axis",
  "(select-y-axis","(select-z-axis","(select-t-axis","(select-c-axis",
  "(select-a-axis","(select-i-axis","(select-s-axis","(select-dx-axis",
  "(select-dy-axis","(select-dz-axis" };
const Selector DEFAULT_OPTION_SELECTAXIS[AXIS_END] = {
  Selector(SELECT_ATTR,0), Selector(SELECT_ATTR,1),
  Selector(SELECT_ZERO),   Selector(SELECT_TIME),
  Selector(SELECT_PROT),   Selector(SELECT_ONE),
  Selector(SELECT_ONE),    Selector(SELECT_WEIG),
  Selector(SELECT_DELT,0), Selector(SELECT_DELT,1),
  Selector(SELECT_ZERO) };
const Selector DEFAULT_OPTION_WEIGHTFACTOR(SELECT_ONE);
keyword_entry g_keyword_connect[] =
  {{ "FLAT",FC_CONNECT_FLAT}
  ,{ "HIER",FC_CONNECT_HIER}
  ,{ "LINE",FC_CONNECT_LINE}
  ,{ "SEQC",FC_CONNECT_SEQC}
  ,{ NULL,0 } 
  };

// implementation
Option::Option
  (
  )
  : m_analysis_name(DEFAULT_OPTION_ANALYSISNAME)
  , m_history()
  , m_data_dimension(DEFAULT_OPTION_NODATADIM)
  , m_number_prototypes(DEFAULT_OPTION_PROTCOUNT)
  , m_number_features(DEFAULT_OPTION_DATACOUNT)
  , m_generic_validity_measure(DEFAULT_OPTION_VALIDITY)
  , m_min_no_of_clusters(DEFAULT_OPTION_CLUSTERRANGE)
  , m_max_no_of_clusters(DEFAULT_OPTION_CLUSTERRANGE)
  , m_distance_shift(DEFAULT_OPTION_DISTSHIFT)
  , m_fuzzifier(DEFAULT_OPTION_FUZZIFIER)
  , m_postscript(DEFAULT_OPTION_POSTSCRIPT)
  , m_graph_mode(DEFAULT_OPTION_GRAPHMODE)
  , m_init_strategy(DEFAULT_OPTION_INIT)
  , m_inter_data_distance(DEFAULT_OPTION_INTERDATADIST)
  , m_interim_output(DEFAULT_OPTION_NOINTERIMOUT)
  , m_maximum_features(DEFAULT_OPTION_MAXFEATURES)
  , m_output(DEFAULT_OPTION_OUTPUT)
  , m_pick_no(DEFAULT_OPTION_PICK)
  , m_substitute_features(DEFAULT_OPTION_SUBSTFEATURES)
  , m_max_iterations(DEFAULT_OPTION_MAXITER)
  , m_threshold(DEFAULT_OPTION_THRESHOLD)
  , m_change(DEFAULT_OPTION_THRESHOLD*2.0)
  , m_unsupervised(DEFAULT_OPTION_UNSUPERVISED)
  , m_weight_factor(DEFAULT_OPTION_WEIGHTFACTOR)
  , m_data_scale(DEFAULT_OPTION_DATASCALE)
  , m_prefer_local(DEFAULT_OPTION_PREFER_LOCAL)
  , m_connect(DEFAULT_OPTION_CONNECT)
  , m_compare_name(DEFAULT_OPTION_COMPARENAME)
  , m_data_depth(DEFAULT_OPTION_DATADEPTH)
  , m_prot_depth(DEFAULT_OPTION_PROTDEPTH)
  , m_separation(DEFAULT_OPTION_COMSEP)
  , m_part_coeff(DEFAULT_OPTION_PARTCOEFF)
  , m_hyper_volume(DEFAULT_OPTION_HYPERVOL)
  , m_contractive(DEFAULT_OPTION_CONTRACTIVE)
  {
  for (int i=0;i<OPTIONS_MAX_CONSTANTS;++i)
    m_constants[i] = DEFAULT_OPTION_CONSTANTS;
  for (int a=AXIS_BEGIN;a!=AXIS_END;++a) 
    m_selector[a] = DEFAULT_OPTION_SELECTAXIS[a];
  m_data_transform.adjust(0);
  m_result_transform.adjust(0);
  m_bbox_local.adjust(0,0);
  m_bbox_global.adjust(0,0);
  m_stat_local.adjust(0,0);
  m_stat_global.adjust(0,0);
  matrix_set_vector(m_sphere_hierarchy,1.0,0.125,2.0);
  }
void
Option::read
  (
  istream& is
  )
  {
  m_unrecognized = "";
  read_until(is,KEYWORD_OPTIONS);
  while (!is_followed_by(is,KEYWORD_CLOSE,false))
    {
    if (is_followed_by(is,KEYWORD_OPTION_ANALYSISNAME,false)) 
      {
      read_until_matching_paranthesis(is,'(',')',analysis_name());
      is.putback(')'); // used as delimiter below
      delete_superfluous_blanks(analysis_name());
      if (analysis_name()=="") analysis_name()=DEFAULT_OPTION_ANALYSISNAME;
      }
    else if (is_followed_by(is,KEYWORD_OPTION_HISTORY,false)) 
      {
      read_until_matching_paranthesis(is,'(',')',history());
      is.putback(')'); // used as delimiter below
      delete_superfluous_blanks(history());
      }
    else if (is_followed_by(is,KEYWORD_OPTION_DATADIM,false)) 
      is >> m_data_dimension;
    else if (is_followed_by(is,KEYWORD_OPTION_PROTCOUNT,false)) 
      is >> m_number_prototypes;
    else if (is_followed_by(is,KEYWORD_OPTION_DATACOUNT,false))
      is >> m_number_features;
    else if (is_followed_by(is,KEYWORD_OPTION_VALIDITY,false)) 
      is >> m_generic_validity_measure;
    else if (is_followed_by(is,KEYWORD_OPTION_CLUSTERRANGE,false)) 
      {
      is >> m_min_no_of_clusters;
      if (!is_followed_by(is,":",false)) 
        { m_max_no_of_clusters=m_min_no_of_clusters; }
      else
        { is >> m_max_no_of_clusters; }
      }
    else if (is_followed_by(is,KEYWORD_OPTION_CONSTANTS,false)) 
      {
      int i;
      for (i=0;i<OPTIONS_MAX_CONSTANTS;++i) 
        { 
        m_constants[i]=DEFAULT_OPTION_CONSTANTS;
        }
      is >> m_constants[0];
      i=0;
      while (is_followed_by(is,":",false))
        { 
        ++i;
        is >> m_constants[i];
        }
      }
    else if (is_followed_by(is,KEYWORD_OPTION_DISTSHIFT,false)) 
      is >> m_distance_shift;
    else if (is_followed_by(is,KEYWORD_OPTION_FUZZIFIER,false)) 
      is >> m_fuzzifier;
    else if (is_followed_by(is,KEYWORD_OPTION_POSTSCRIPT,false)) 
      is >> m_postscript;
    else if (is_followed_by(is,KEYWORD_OPTION_GRAPHMODE,false)) 
      is >> m_graph_mode;
    else if (is_followed_by(is,KEYWORD_OPTION_INIT,false)) 
      init() = is_followed_by(is,g_keyword_init,false,true,DEFAULT_OPTION_INIT); 
    else if (is_followed_by(is,KEYWORD_OPTION_INTERDATADIST,false)) 
      is >> m_inter_data_distance;
    else if (is_followed_by(is,KEYWORD_OPTION_INTERIMOUT,false)) 
      is >> m_interim_output;
    else if (is_followed_by(is,KEYWORD_OPTION_MAXFEATURES,false)) 
      is >> m_maximum_features;
    else if (is_followed_by(is,KEYWORD_OPTION_OUTPUT,false)) 
      output() = is_followed_by(is,g_keyword_output,false,true,DEFAULT_OPTION_OUTPUT);
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_X],false)) 
      is >> m_selector[AXIS_X];
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_Y],false)) 
      is >> m_selector[AXIS_Y];
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_Z],false)) 
      is >> m_selector[AXIS_Z];
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_T],false)) 
      is >> m_selector[AXIS_T];
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_C],false)) 
      is >> m_selector[AXIS_C];
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_A],false)) 
      is >> m_selector[AXIS_A];
    else if (is_followed_by(is,KEYWORD_OPTION_SELECTAXIS[AXIS_I],false)) 
      is >> m_selector[AXIS_I];