localunsupclus.cpp

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

/*
  
  Context       : Fuzzy Clustering Algorithms

  Author        : Frank Hoeppner, see also AUTHORS file 

  Description   : implementation of class module LocalUnsupClus
                  
  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 LocalUnsupClus_SOURCE
#define LocalUnsupClus_SOURCE

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



// necessary includes
#include "LocalUnsupClus.hpp"

// data


// implementation
template < class ANALYSIS >
LocalUnsupClus< ANALYSIS >::LocalUnsupClus
  (
  Algorithm<ANALYSIS>* ap_init_alg,
  Algorithm<ANALYSIS>* ap_clst_alg,
  Algorithm<ANALYSIS>* ap_valm_alg,
  Algorithm<ANALYSIS>* ap_itrm_alg, /* called for interim solutions */
  Algorithm<ANALYSIS>* ap_alg /* successor */
  )
  : mp_succ_alg(ap_alg)
  , mp_init_alg(ap_init_alg)
  , mp_clst_alg(ap_clst_alg)
  , mp_valm_alg(ap_valm_alg)
  , mp_itrm_alg(ap_itrm_alg)
  , mp_psop_alg(new ProtSetOp<ANALYSIS>(new NoOperation<ANALYSIS>()))
  
  {
  
  }
template < class ANALYSIS >
LocalUnsupClus< ANALYSIS >::~LocalUnsupClus
  (
  )
  {
  FUNCLOG("~LocalUnsupClus");
  delete mp_psop_alg;
  delete mp_init_alg;
  delete mp_clst_alg;
  delete mp_valm_alg;
  delete mp_itrm_alg;
  delete mp_succ_alg;
  }
template < class ANALYSIS >
void
LocalUnsupClus< ANALYSIS >::operator()
  (
  ANALYSIS& a_analysis
  )
  {
  FUNCLOG("LocalUnsupClus");
  
  if (a_analysis.option().init()==FC_INIT_AUTO)
    {
    a_analysis.option().number_prototypes() =
      a_analysis.option().max_no_of_clusters();
    (*mp_init_alg)(a_analysis);
    }

  (*mp_clst_alg)(a_analysis);

  if (    (a_analysis.option().unsupervised()) 
       && (a_analysis.option().number_prototypes()>0))
    {
    bool changes;
    do
      {
      (*mp_valm_alg)(a_analysis);

      changes=false;
      for (
          typename ANALYSIS::prot_iter i_prot(a_analysis.prototypes().begin());
          i_prot != a_analysis.prototypes().end();
          ++i_prot
          )
        {
        changes |= ((*i_prot).unsupervised_operation()!=FC_USO_UNTOUCHED);
        }
      trace("prototypes",a_analysis.prototypes());

      if (changes)
        {
        (*mp_psop_alg)(a_analysis);
        trace("no. remaining prototypes",a_analysis.option().number_prototypes());
        if (a_analysis.option().interim_output() != DEFAULT_OPTION_NOINTERIMOUT)
          { (*mp_itrm_alg)(a_analysis); }
        (*mp_clst_alg)(a_analysis);
        if (a_analysis.option().interim_output() != DEFAULT_OPTION_NOINTERIMOUT)
          { (*mp_itrm_alg)(a_analysis); }
        }
      }
    while (changes);
    }

  (*mp_succ_alg)(a_analysis);
  
  }

// template instantiation



#endif // LocalUnsupClus_SOURCE