vektor.cpp

java fuzzy cmeans code

// Vektor.cpp: Implementierung der Klasse CVektor.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

//////////////////////////////////////////////////////////////////////
// Konstruktion/Destruktion
//////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "Vektor.h"

/*
	Author		: Bernd Allmendinger
	Date		: 14.02.2000
	e-mail		: [e-mail]
	homepage	: www.neurocomputing.de
	Version		: 1.0
*/

//////////////////////////////////////////////////////////////////////
// Konstruktion/Destruktion
//////////////////////////////////////////////////////////////////////

CVektor::CVektor()
{ nl=nh=0;
  dim = 0;
  wert = 0;
}

CVektor::~CVektor()
{ 
  if (wert)
  { 
	delete [] (wert+nl);  
	// delete [] wert;
    wert = 0;
  }
  dim = 0;
  nl=nh=0;
}

void CVektor::operator=(CVektor & a)
{ int i;

   // Wenn dim des vektors Null ist, dann erst speicher allocieren
   if (dim == 0)
   { setDim(a.nl, a.nh);
   }
   
   if (dim == a.getDim())
   {  for (i=nl; i < nh; i++)
		wert[i] = a.wert[i];
   }
}



int CVektor::entfernen_zeile(double Zahl)          /*
---------------------------------------------------------------         */
{ /* n = Dimension von Array (anzahl der Elemente) a[0..n-1] ---> dimension n
  z.B zahl = 0
  Rueckgabe: neue dimension des arrays a
  Beginnt von index Null und entfernt die zellen die Null enthalten in dem die 
  werte ungleich Null aufschliesen.

  Beispiel: Eingabe: a[0]=3, a[1]=0,a[2]=0,a[3]=11,a[4]=6,a[4]=0; Dimension n = 6
            Nach bedingung der procedure:
                      a[0]=3, a[1]=11,a[2]=6,a[3]=0,a[4]=0,a[4]=0; Dimension n = 3
  */
  int i, k;

  // Suchen der ersten Null im array a
  for (k=nl; k <= nh && wert[k] != Zahl; k++) ;
  i=0;
  while (k <= nh && i <= nh)
  { for (i=k; i <= nh && wert[i] == Zahl; i++) ;
    
     if (i < dim)
	 { wert[k]=wert[i];
	   k++;
	   wert[i]=Zahl;
	 }
  }

  // Berechnen der neuen Dimension
  for (k=nl; k <= nh && wert[k] != Zahl; k++) ;
  return (k);


}




int CVektor::getDim()
{  
   return(dim);
   
}

int CVektor::setDim(int unl, int unh)
{ int i;

    nl=unl; 
	nh=unh;

	if (dim == 0)
	{	dim = unh-unl+1;
		wert=new double[dim];
		wert -= nl;
		if (wert==NULL) 
			return(NOSPEICHER);
		// return wert-nl;
		for (i=nl; i <= nh; i++)
		wert[i] = 0;
		
/*		
		dim = n;  
		wert = new double [dim];  
		if (wert == NULL) return(NOSPEICHER);
		for (i=0; i < dim; i++)
		wert[i] = 0;
*/
	}

	return(OK);
}

void CVektor::init(double initwert)
{ int i;

  for (i=nl; i <= nh; i++)
	wert[i] = initwert;
}

void CVektor::printWerte()
{ int i;
  
  printf("\nWerte von Vektor mit dim %d :\n", dim);

  for (i=nl; i <= nh; i++) printf(" %4.3f", wert[i]);

  printf(";\n");
}

void CVektor::fprintWerte(char* fname)
{ int i;
  FILE* pro;

  if (!(pro = fopen(fname, "w")))
  { return;
  }
  fprintf(pro, "\nWerte von Vektor mit dim %d :\n", dim);

  for (i=nl; i <= nh; i++) fprintf(pro, "%4.3f\n", wert[i]);

  fclose(pro);
}

double CVektor::sum()
{ int i;
  
  double dsum = 0.0;
  for (i=nl; i <= nh; i++) dsum += wert[i];

  return(dsum);
}


double CVektor::betrag()
{ int i;
 
  double bet = 0.0;
  for (i=nl; i <= nh; i++) 
	  bet += wert[i]*wert[i];

  return(sqrt(bet));
}


double CVektor::mittelwert()
{ 
  double dsum = sum();

  if (dim > 0)
    return(dsum/dim);
  else
	return(0.0);
}

double CVektor::vmax(int* index)
{ int i;
  double maxwert;
  
  maxwert= -MAXREAL;
  for (i=nl; i <= nh; i++) 
	 if (wert[i] > maxwert)
	 { maxwert = wert[i];
	   *index = i;
	 }

  return(maxwert);
}

double CVektor::vmin(int* index)
{ int i;
  double minwert;
  
  minwert= MAXREAL;
  for (i=nl; i <= nh; i++) 
	 if (wert[i] < minwert)
	 { minwert = wert[i];
	   *index = i;
	 }

  return(minwert);
}
//////////////////////////////////////////////////////////////////////
// CVektorInt Klasse
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Konstruktion/Destruktion
//////////////////////////////////////////////////////////////////////

CVektorInt::CVektorInt()
{ dim = 0;
  wert = 0;
}

CVektorInt::~CVektorInt()
{ if (wert)
  { delete [] wert;
    wert = 0;
  }
  dim = 0;
}


void CVektorInt::operator=(CVektorInt & a)
{ int i;

   // Wenn dim des vektors Null ist, dann erst speicher allocieren
   if (dim == 0)
   { setDim(a.getDim());
   }
   
   if (dim == a.getDim())
   {  for (i=0; i < dim; i++)
		wert[i] = a.wert[i];
   }
}


int CVektorInt::entfernen_zeile(int Zahl)        /*
---------------------------------------------------------------         */
{ /*
  z.B zahl = 0
  n = Dimension von Array (anzahl der Elemente) a[0..n-1] ---> dimension n
  Rueckgabe: neue dimension des arrays a
  Beginnt von index Null und entfernt die zellen die Null enthalten in dem die 
  werte ungleich Null aufschliesen.

  Beispiel: Eingabe: a[0]=3, a[1]=0,a[2]=0,a[3]=11,a[4]=6,a[4]=0; Dimension n = 6
            Nach bedingung der procedure:
                      a[0]=3, a[1]=11,a[2]=6,a[3]=0,a[4]=0,a[4]=0; Dimension n = 3
  */
  int i, k;

  // Suchen der ersten Null im array a
  for (k=0; k < dim && wert[k] != Zahl; k++) ;
  i=0;
  while (k < dim && i < dim)
  { for (i=k; i < dim && wert[i] == Zahl; i++) ;
    
     if (i < dim)
	 { wert[k]=wert[i];
	   k++;
	   wert[i]=Zahl;
	 }
  }

  // Berechnen der neuen Dimension
  for (k=0; k < dim && wert[k] != Zahl; k++) ;
  return (k);


}

int CVektorInt::finde(int start, int suchwert)					/*
------------------------------------------------------------------------			*/
{ /* sucht den wert "wert" im array a und liefert die Position