clusttool.cpp File Reference

#include "clusttool.h"
#include <cmath>
#include <locale>
#include <sstream>
#include "emalloc.h"

Go to the source code of this file.

Macros
#define	_USE_MATH_DEFINES
#define	TOKENSIZE   80
	max size of tokens read from an input file More...
#define	QUOTED_TOKENSIZE   "79"
#define	MAXSAMPLESIZE   65535
	max num of dimensions in feature space More...

Functions
uint16_t	ReadSampleSize (TFile *fp)
PARAM_DESC *	ReadParamDesc (TFile *fp, uint16_t N)
PROTOTYPE *	ReadPrototype (TFile *fp, uint16_t N)
void	WriteParamDesc (FILE *File, uint16_t N, const PARAM_DESC ParamDesc[])
void	WritePrototype (FILE *File, uint16_t N, PROTOTYPE *Proto)

Macro Definition Documentation

_USE_MATH_DEFINES

#define _USE_MATH_DEFINES

Definition at line 18 of file clusttool.cpp.

MAXSAMPLESIZE

#define MAXSAMPLESIZE   65535

max num of dimensions in feature space

Definition at line 31 of file clusttool.cpp.

QUOTED_TOKENSIZE

#define QUOTED_TOKENSIZE   "79"

Definition at line 30 of file clusttool.cpp.

TOKENSIZE

#define TOKENSIZE   80

max size of tokens read from an input file

Definition at line 29 of file clusttool.cpp.

Function Documentation

ReadParamDesc()

PARAM_DESC* ReadParamDesc	(	TFile *	fp,
		uint16_t	N
	)

This routine reads textual descriptions of sets of parameters which describe the characteristics of feature dimensions.

Parameters

fp	open text file to read N parameter descriptions from
N	number of parameter descriptions to read

Returns

Pointer to an array of parameter descriptors.

Note

Globals: None

Definition at line 140 of file clusttool.cpp.

                                                 {
  PARAM_DESC *ParamDesc;
 
  ParamDesc = static_cast<PARAM_DESC *>(Emalloc (N * sizeof (PARAM_DESC)));
  for (int i = 0; i < N; i++) {
    const int kMaxLineSize = TOKENSIZE * 4;
    char line[kMaxLineSize];
    ASSERT_HOST(fp->FGets(line, kMaxLineSize) != nullptr);
    std::istringstream stream(line);
    // Use "C" locale (needed for float values Min, Max).
    stream.imbue(std::locale::classic());
    std::string linear_token;
    stream >> linear_token;
    std::string essential_token;
    stream >> essential_token;
    stream >> ParamDesc[i].Min;
    stream >> ParamDesc[i].Max;
    ASSERT_HOST(!stream.fail());
    ParamDesc[i].Circular = (linear_token[0] == 'c');
    ParamDesc[i].NonEssential = (essential_token[0] != 'e');
    ParamDesc[i].Range = ParamDesc[i].Max - ParamDesc[i].Min;
    ParamDesc[i].HalfRange = ParamDesc[i].Range / 2;
    ParamDesc[i].MidRange = (ParamDesc[i].Max + ParamDesc[i].Min) / 2;
  }
  return (ParamDesc);
}

ReadPrototype()

PROTOTYPE* ReadPrototype	(	TFile *	fp,
		uint16_t	N
	)

This routine reads a textual description of a prototype from the specified file.

Parameters

fp	open text file to read prototype from
N	number of dimensions used in prototype

Returns

List of prototypes

Note

Globals: None

Definition at line 176 of file clusttool.cpp.

                                                {
  char sig_token[TOKENSIZE], shape_token[TOKENSIZE];
  PROTOTYPE *Proto;
  int SampleCount;
  int i;
 
  const int kMaxLineSize = TOKENSIZE * 4;
  char line[kMaxLineSize];
  if (fp->FGets(line, kMaxLineSize) == nullptr ||
      sscanf(line, "%" QUOTED_TOKENSIZE "s %" QUOTED_TOKENSIZE "s %d",
             sig_token, shape_token, &SampleCount) != 3) {
    tprintf("Invalid prototype: %s\n", line);
    return nullptr;
  }
  Proto = static_cast<PROTOTYPE *>(Emalloc(sizeof(PROTOTYPE)));
  Proto->Cluster = nullptr;
  Proto->Significant = (sig_token[0] == 's');
 
  switch (shape_token[0]) {
    case 's':
      Proto->Style = spherical;
      break;
    case 'e':
      Proto->Style = elliptical;
      break;
    case 'a':
      Proto->Style = automatic;
      break;
    default:
      tprintf("Invalid prototype style specification:%s\n", shape_token);
      Proto->Style = elliptical;
  }
 
  ASSERT_HOST(SampleCount >= 0);
  Proto->NumSamples = SampleCount;
 
  Proto->Mean = ReadNFloats(fp, N, nullptr);
  ASSERT_HOST(Proto->Mean != nullptr);
 
  switch (Proto->Style) {
    case spherical:
      ASSERT_HOST(ReadNFloats(fp, 1, &(Proto->Variance.Spherical)) != nullptr);
      Proto->Magnitude.Spherical =
          1.0 / sqrt(2.0 * M_PI * Proto->Variance.Spherical);
      Proto->TotalMagnitude = pow(Proto->Magnitude.Spherical, static_cast<float>(N));
      Proto->LogMagnitude = log(static_cast<double>(Proto->TotalMagnitude));
      Proto->Weight.Spherical = 1.0 / Proto->Variance.Spherical;
      Proto->Distrib = nullptr;
      break;
    case elliptical:
      Proto->Variance.Elliptical = ReadNFloats(fp, N, nullptr);
      ASSERT_HOST(Proto->Variance.Elliptical != nullptr);
      Proto->Magnitude.Elliptical = static_cast<float *>(Emalloc(N * sizeof(float)));
      Proto->Weight.Elliptical = static_cast<float *>(Emalloc(N * sizeof(float)));
      Proto->TotalMagnitude = 1.0;
      for (i = 0; i < N; i++) {
        Proto->Magnitude.Elliptical[i] =
            1.0 / sqrt(2.0 * M_PI * Proto->Variance.Elliptical[i]);
        Proto->Weight.Elliptical[i] = 1.0 / Proto->Variance.Elliptical[i];
        Proto->TotalMagnitude *= Proto->Magnitude.Elliptical[i];
      }
      Proto->LogMagnitude = log(static_cast<double>(Proto->TotalMagnitude));
      Proto->Distrib = nullptr;
      break;
    default:
      Efree(Proto);
      tprintf("Invalid prototype style\n");
      return nullptr;
  }
  return Proto;
}

ReadSampleSize()

uint16_t ReadSampleSize

(

TFile *

fp

)

This routine reads a single integer from the specified file and checks to ensure that it is between 0 and MAXSAMPLESIZE.

Parameters

fp	open text file to read sample size from

Returns

Sample size

Note

Globals: None

Definition at line 120 of file clusttool.cpp.

                                   {
  int SampleSize = 0;
 
  const int kMaxLineSize = 100;
  char line[kMaxLineSize];
  ASSERT_HOST(fp->FGets(line, kMaxLineSize) != nullptr);
  ASSERT_HOST(sscanf(line, "%d", &SampleSize) == 1);
  ASSERT_HOST(SampleSize >= 0 && SampleSize <= MAXSAMPLESIZE);
  return SampleSize;
}

WriteParamDesc()

void WriteParamDesc	(	FILE *	File,
		uint16_t	N,
		const PARAM_DESC	ParamDesc[]
	)

This routine writes an array of dimension descriptors to the specified text file.

Parameters

File	open text file to write param descriptors to
N	number of param descriptors to write
ParamDesc	array of param descriptors to write

Definition at line 255 of file clusttool.cpp.

                                                                          {
  int i;
 
  for (i = 0; i < N; i++) {
    if (ParamDesc[i].Circular)
      fprintf (File, "circular ");
    else
      fprintf (File, "linear   ");
 
    if (ParamDesc[i].NonEssential)
      fprintf (File, "non-essential ");
    else
      fprintf (File, "essential     ");
 
    fprintf (File, "%10.6f %10.6f\n", ParamDesc[i].Min, ParamDesc[i].Max);
  }
}

WritePrototype()

void WritePrototype	(	FILE *	File,
		uint16_t	N,
		PROTOTYPE *	Proto
	)

This routine writes a textual description of a prototype to the specified text file.

Parameters

File	open text file to write prototype to
N	number of dimensions in feature space
Proto	prototype to write out

Definition at line 280 of file clusttool.cpp.

                                                              {
  int i;
 
  if (Proto->Significant)
    fprintf (File, "significant   ");
  else
    fprintf (File, "insignificant ");
  WriteProtoStyle (File, static_cast<PROTOSTYLE>(Proto->Style));
  fprintf (File, "%6d\n\t", Proto->NumSamples);
  WriteNFloats (File, N, Proto->Mean);
  fprintf (File, "\t");
 
  switch (Proto->Style) {
    case spherical:
      WriteNFloats (File, 1, &(Proto->Variance.Spherical));
      break;
    case elliptical:
      WriteNFloats (File, N, Proto->Variance.Elliptical);
      break;
    case mixed:
      for (i = 0; i < N; i++)
      switch (Proto->Distrib[i]) {
        case normal:
          fprintf (File, " %9s", "normal");
          break;
        case uniform:
          fprintf (File, " %9s", "uniform");
          break;
        case D_random:
          fprintf (File, " %9s", "random");
          break;
        case DISTRIBUTION_COUNT:
          ASSERT_HOST(!"Distribution count not allowed!");
      }
      fprintf (File, "\n\t");
      WriteNFloats (File, N, Proto->Variance.Elliptical);
  }
}