adaptive.h File Reference

#include "oldlist.h"
#include "intproto.h"
#include <stdio.h>

Go to the source code of this file.

Classes
struct	TEMP_PROTO_STRUCT
struct	TEMP_CONFIG_STRUCT
struct	PERM_CONFIG_STRUCT
union	ADAPTED_CONFIG
struct	ADAPT_CLASS_STRUCT
struct	ADAPT_TEMPLATES_STRUCT

Macros
#define	NumNonEmptyClassesIn(Template)   ((Template)->NumNonEmptyClasses)
#define	IsEmptyAdaptedClass(Class)
#define	ConfigIsPermanent(Class, ConfigId)   (test_bit ((Class)->PermConfigs, ConfigId))
#define	MakeConfigPermanent(Class, ConfigId)   (SET_BIT ((Class)->PermConfigs, ConfigId))
#define	MakeProtoPermanent(Class, ProtoId)   (SET_BIT ((Class)->PermProtos, ProtoId))
#define	TempConfigFor(Class, ConfigId)   ((Class)->Config[ConfigId].Temp)
#define	PermConfigFor(Class, ConfigId)   ((Class)->Config[ConfigId].Perm)
#define	IncreaseConfidence(TempConfig)   ((TempConfig)->NumTimesSeen++)

Typedefs
typedef TEMP_PROTO_STRUCT *	TEMP_PROTO
typedef TEMP_CONFIG_STRUCT *	TEMP_CONFIG
typedef PERM_CONFIG_STRUCT *	PERM_CONFIG
typedef ADAPT_CLASS_STRUCT *	ADAPT_CLASS
typedef ADAPT_TEMPLATES_STRUCT *	ADAPT_TEMPLATES

Functions
void	AddAdaptedClass (ADAPT_TEMPLATES Templates, ADAPT_CLASS Class, CLASS_ID ClassId)
void	FreeTempProto (void *arg)
void	FreeTempConfig (TEMP_CONFIG Config)
ADAPT_CLASS	NewAdaptedClass ()
void	free_adapted_class (ADAPT_CLASS adapt_class)
void	free_adapted_templates (ADAPT_TEMPLATES templates)
TEMP_CONFIG	NewTempConfig (int MaxProtoId, int FontinfoId)
TEMP_PROTO	NewTempProto ()
ADAPT_CLASS	ReadAdaptedClass (FILE *File)
PERM_CONFIG	ReadPermConfig (FILE *File)
TEMP_CONFIG	ReadTempConfig (FILE *File)
void	WriteAdaptedClass (FILE *File, ADAPT_CLASS Class, int NumConfigs)
void	WritePermConfig (FILE *File, PERM_CONFIG Config)
void	WriteTempConfig (FILE *File, TEMP_CONFIG Config)

Macro Definition Documentation

ConfigIsPermanent

#define ConfigIsPermanent	(		Class,
			ConfigId
	)		(test_bit ((Class)->PermConfigs, ConfigId))

Definition at line 93 of file adaptive.h.

IncreaseConfidence

#define IncreaseConfidence

(

TempConfig

)

((TempConfig)->NumTimesSeen++)

Definition at line 108 of file adaptive.h.

IsEmptyAdaptedClass

#define IsEmptyAdaptedClass

(

Class

)

Value:

((Class)->NumPermConfigs == 0 &&      \
(Class)->TempProtos == NIL_LIST)

Definition at line 90 of file adaptive.h.

MakeConfigPermanent

#define MakeConfigPermanent	(		Class,
			ConfigId
	)		(SET_BIT ((Class)->PermConfigs, ConfigId))

Definition at line 96 of file adaptive.h.

MakeProtoPermanent

#define MakeProtoPermanent	(		Class,
			ProtoId
	)		(SET_BIT ((Class)->PermProtos, ProtoId))

Definition at line 99 of file adaptive.h.

NumNonEmptyClassesIn

#define NumNonEmptyClassesIn

(

Template

)

((Template)->NumNonEmptyClasses)

Definition at line 88 of file adaptive.h.

PermConfigFor

#define PermConfigFor	(		Class,
			ConfigId
	)		((Class)->Config[ConfigId].Perm)

Definition at line 105 of file adaptive.h.

TempConfigFor

#define TempConfigFor	(		Class,
			ConfigId
	)		((Class)->Config[ConfigId].Temp)

Definition at line 102 of file adaptive.h.

Typedef Documentation

ADAPT_CLASS

typedef ADAPT_CLASS_STRUCT* ADAPT_CLASS

Definition at line 73 of file adaptive.h.

ADAPT_TEMPLATES

typedef ADAPT_TEMPLATES_STRUCT* ADAPT_TEMPLATES

Definition at line 83 of file adaptive.h.

PERM_CONFIG

typedef PERM_CONFIG_STRUCT* PERM_CONFIG

Definition at line 55 of file adaptive.h.

TEMP_CONFIG

typedef TEMP_CONFIG_STRUCT* TEMP_CONFIG

Definition at line 48 of file adaptive.h.

TEMP_PROTO

typedef TEMP_PROTO_STRUCT* TEMP_PROTO

Definition at line 37 of file adaptive.h.

Function Documentation

AddAdaptedClass()

void AddAdaptedClass	(	ADAPT_TEMPLATES	Templates,
		ADAPT_CLASS	Class,
		CLASS_ID	ClassId
	)

This routine adds a new adapted class to an existing set of adapted templates.

Parameters

Templates	set of templates to add new class to
Class	new class to add to templates
ClassId	class id to associate with new class

Note

Globals: none

Exceptions: none

History: Thu Mar 14 13:06:09 1991, DSJ, Created.

Definition at line 49 of file adaptive.cpp.

                                       {
  INT_CLASS IntClass;

  assert (Templates != NULL);
  assert (Class != NULL);
  assert (LegalClassId (ClassId));
  assert (UnusedClassIdIn (Templates->Templates, ClassId));
  assert (Class->NumPermConfigs == 0);

  IntClass = NewIntClass (1, 1);
  AddIntClass (Templates->Templates, ClassId, IntClass);

  assert (Templates->Class[ClassId] == NULL);
  Templates->Class[ClassId] = Class;

}                                /* AddAdaptedClass */

free_adapted_class()

void free_adapted_class

(

ADAPT_CLASS

adapt_class

)

Definition at line 136 of file adaptive.cpp.

                                                 {
  int i;

  for (i = 0; i < MAX_NUM_CONFIGS; i++) {
    if (ConfigIsPermanent (adapt_class, i)
      && PermConfigFor (adapt_class, i) != NULL)
      FreePermConfig (PermConfigFor (adapt_class, i));
    else if (!ConfigIsPermanent (adapt_class, i)
      && TempConfigFor (adapt_class, i) != NULL)
      FreeTempConfig (TempConfigFor (adapt_class, i));
  }
  FreeBitVector (adapt_class->PermProtos);
  FreeBitVector (adapt_class->PermConfigs);
  destroy_nodes (adapt_class->TempProtos, FreeTempProto);
  Efree(adapt_class);
}

free_adapted_templates()

void free_adapted_templates

(

ADAPT_TEMPLATES

templates

)

Definition at line 199 of file adaptive.cpp.

                                                       {

  if (templates != NULL) {
    int i;
    for (i = 0; i < (templates->Templates)->NumClasses; i++)
      free_adapted_class (templates->Class[i]);
    free_int_templates (templates->Templates);
    Efree(templates);
  }
}

FreeTempConfig()

void FreeTempConfig

(

TEMP_CONFIG

Config

)

This routine frees all memory consumed by a temporary configuration.

Parameters

Config

config to be freed

Note

Globals: none

Exceptions: none

History: Thu Mar 14 13:34:23 1991, DSJ, Created.

Definition at line 80 of file adaptive.cpp.

                                        {
  assert (Config != NULL);

  destroy_nodes (Config->ContextsSeen, memfree);
  FreeBitVector (Config->Protos);
  free_struct (Config, sizeof (TEMP_CONFIG_STRUCT), "TEMP_CONFIG_STRUCT");

}                                /* FreeTempConfig */

FreeTempProto()

void FreeTempProto

(

void *

arg

)

Definition at line 90 of file adaptive.cpp.

                              {
  PROTO proto = (PROTO) arg;

  free_struct (proto, sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT");
}

NewAdaptedClass()

ADAPT_CLASS NewAdaptedClass

(

)

This operation allocates and initializes a new adapted class data structure and returns a ptr to it.

Returns

Ptr to new class data structure.

Note

Globals: none

Exceptions: none

History: Thu Mar 14 12:58:13 1991, DSJ, Created.

Definition at line 113 of file adaptive.cpp.

                              {
  ADAPT_CLASS Class;
  int i;

  Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
  Class->NumPermConfigs = 0;
  Class->MaxNumTimesSeen = 0;
  Class->TempProtos = NIL_LIST;

  Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
  Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
  zero_all_bits (Class->PermProtos, WordsInVectorOfSize (MAX_NUM_PROTOS));
  zero_all_bits (Class->PermConfigs, WordsInVectorOfSize (MAX_NUM_CONFIGS));

  for (i = 0; i < MAX_NUM_CONFIGS; i++)
    TempConfigFor (Class, i) = NULL;

  return (Class);

}                                /* NewAdaptedClass */

NewTempConfig()

TEMP_CONFIG NewTempConfig	(	int	MaxProtoId,
		int	FontinfoId
	)

This routine allocates and returns a new temporary config.

Parameters

MaxProtoId	max id of any proto in new config
FontinfoId	font information from pre-trained templates

Returns

Ptr to new temp config.

Note

Globals: none

Exceptions: none

History: Thu Mar 14 13:28:21 1991, DSJ, Created.

Definition at line 223 of file adaptive.cpp.

                                                          {
  TEMP_CONFIG Config;
  int NumProtos = MaxProtoId + 1;

  Config =
    (TEMP_CONFIG) alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
    "TEMP_CONFIG_STRUCT");
  Config->Protos = NewBitVector (NumProtos);

  Config->NumTimesSeen = 1;
  Config->MaxProtoId = MaxProtoId;
  Config->ProtoVectorSize = WordsInVectorOfSize (NumProtos);
  Config->ContextsSeen = NIL_LIST;
  zero_all_bits (Config->Protos, Config->ProtoVectorSize);
  Config->FontinfoId = FontinfoId;

  return (Config);

}                                /* NewTempConfig */

NewTempProto()

TEMP_PROTO NewTempProto

(

)

This routine allocates and returns a new temporary proto.

Returns

Ptr to new temporary proto.

Note

Globals: none

Exceptions: none

History: Thu Mar 14 13:31:31 1991, DSJ, Created.

Definition at line 254 of file adaptive.cpp.

                          {
  return ((TEMP_PROTO)
    alloc_struct (sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT"));
}                                /* NewTempProto */

ReadAdaptedClass()

ADAPT_CLASS ReadAdaptedClass

(

FILE *

File

)

Read an adapted class description from File and return a ptr to the adapted class.

Parameters

File	open file to read adapted class from

Returns

Ptr to new adapted class.

Note

Globals: none

Exceptions: none

History: Tue Mar 19 14:11:01 1991, DSJ, Created.

Definition at line 313 of file adaptive.cpp.

                                         {
  int32_t NumTempProtos;
  int32_t NumConfigs;
  int i;
  ADAPT_CLASS Class;
  TEMP_PROTO TempProto;

  /* first read high level adapted class structure */
  Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
  fread ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);

  /* then read in the definitions of the permanent protos and configs */
  Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
  Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
  fread ((char *) Class->PermProtos, sizeof (uinT32),
    WordsInVectorOfSize (MAX_NUM_PROTOS), File);
  fread ((char *) Class->PermConfigs, sizeof (uinT32),
    WordsInVectorOfSize (MAX_NUM_CONFIGS), File);

  /* then read in the list of temporary protos */
  fread (&NumTempProtos, sizeof(NumTempProtos), 1, File);
  Class->TempProtos = NIL_LIST;
  for (i = 0; i < NumTempProtos; i++) {
    TempProto =
      (TEMP_PROTO) alloc_struct (sizeof (TEMP_PROTO_STRUCT),
      "TEMP_PROTO_STRUCT");
    fread ((char *) TempProto, sizeof (TEMP_PROTO_STRUCT), 1, File);
    Class->TempProtos = push_last (Class->TempProtos, TempProto);
  }

  /* then read in the adapted configs */
  fread (&NumConfigs, sizeof(NumConfigs), 1, File);
  for (i = 0; i < NumConfigs; i++)
    if (test_bit (Class->PermConfigs, i))
      Class->Config[i].Perm = ReadPermConfig (File);
    else
      Class->Config[i].Temp = ReadTempConfig (File);

  return (Class);

}                                /* ReadAdaptedClass */

ReadPermConfig()

PERM_CONFIG ReadPermConfig

(

FILE *

File

)

Read a permanent configuration description from File and return a ptr to it.

Parameters

File	open file to read permanent config from

Returns

Ptr to new permanent configuration description.

Note

Globals: none

Exceptions: none

History: Tue Mar 19 14:25:26 1991, DSJ, Created.

Definition at line 402 of file adaptive.cpp.

                                       {
  PERM_CONFIG Config = (PERM_CONFIG) alloc_struct(sizeof(PERM_CONFIG_STRUCT),
                                                  "PERM_CONFIG_STRUCT");
  uinT8 NumAmbigs;
  fread ((char *) &NumAmbigs, sizeof(uinT8), 1, File);
  Config->Ambigs = new UNICHAR_ID[NumAmbigs + 1];
  fread(Config->Ambigs, sizeof(UNICHAR_ID), NumAmbigs, File);
  Config->Ambigs[NumAmbigs] = -1;
  fread(&(Config->FontinfoId), sizeof(int), 1, File);

  return (Config);

}                                /* ReadPermConfig */

ReadTempConfig()

TEMP_CONFIG ReadTempConfig

(

FILE *

File

)

Read a temporary configuration description from File and return a ptr to it.

Parameters

File	open file to read temporary config from

Returns

Ptr to new temporary configuration description.

Note

Globals: none

Exceptions: none

History: Tue Mar 19 14:29:59 1991, DSJ, Created.

Definition at line 429 of file adaptive.cpp.

                                       {
  TEMP_CONFIG Config;

  Config =
    (TEMP_CONFIG) alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
    "TEMP_CONFIG_STRUCT");
  fread ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);

  Config->Protos = NewBitVector (Config->ProtoVectorSize * BITSINLONG);
  fread ((char *) Config->Protos, sizeof (uinT32),
    Config->ProtoVectorSize, File);

  return (Config);

}                                /* ReadTempConfig */

WriteAdaptedClass()

void WriteAdaptedClass	(	FILE *	File,
		ADAPT_CLASS	Class,
		int	NumConfigs
	)

This routine writes a binary representation of Class to File.

Parameters

File	open file to write Class to
Class	adapted class to write to File
NumConfigs	number of configs in Class

Note

Globals: none

Exceptions: none

History: Tue Mar 19 13:33:51 1991, DSJ, Created.

Definition at line 459 of file adaptive.cpp.

                                                                      {
  int NumTempProtos;
  LIST TempProtos;
  int i;

  /* first write high level adapted class structure */
  fwrite ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);

  /* then write out the definitions of the permanent protos and configs */
  fwrite ((char *) Class->PermProtos, sizeof (uinT32),
    WordsInVectorOfSize (MAX_NUM_PROTOS), File);
  fwrite ((char *) Class->PermConfigs, sizeof (uinT32),
    WordsInVectorOfSize (MAX_NUM_CONFIGS), File);

  /* then write out the list of temporary protos */
  NumTempProtos = count (Class->TempProtos);
  fwrite ((char *) &NumTempProtos, sizeof (int), 1, File);
  TempProtos = Class->TempProtos;
  iterate (TempProtos) {
    void* proto = first_node(TempProtos);
    fwrite ((char *) proto, sizeof (TEMP_PROTO_STRUCT), 1, File);
  }

  /* then write out the adapted configs */
  fwrite ((char *) &NumConfigs, sizeof (int), 1, File);
  for (i = 0; i < NumConfigs; i++)
    if (test_bit (Class->PermConfigs, i))
      WritePermConfig (File, Class->Config[i].Perm);
    else
      WriteTempConfig (File, Class->Config[i].Temp);

}                                /* WriteAdaptedClass */

WritePermConfig()

void WritePermConfig	(	FILE *	File,
		PERM_CONFIG	Config
	)

This routine writes a binary representation of a permanent configuration to File.

Parameters

File	open file to write Config to
Config	permanent config to write to File

Note

Globals: none

Exceptions: none

History: Tue Mar 19 13:55:44 1991, DSJ, Created.

Definition at line 535 of file adaptive.cpp.

                                                     {
  uinT8 NumAmbigs = 0;

  assert (Config != NULL);
  while (Config->Ambigs[NumAmbigs] > 0) ++NumAmbigs;

  fwrite((char *) &NumAmbigs, sizeof(uinT8), 1, File);
  fwrite(Config->Ambigs, sizeof(UNICHAR_ID), NumAmbigs, File);
  fwrite(&(Config->FontinfoId), sizeof(int), 1, File);
}                                /* WritePermConfig */

WriteTempConfig()

void WriteTempConfig	(	FILE *	File,
		TEMP_CONFIG	Config
	)

This routine writes a binary representation of a temporary configuration to File.

Parameters

File	open file to write Config to
Config	temporary config to write to File

Note

Globals: none

Exceptions: none

History: Tue Mar 19 14:00:28 1991, DSJ, Created.

Definition at line 559 of file adaptive.cpp.

                                                     {
  assert (Config != NULL);
                                 /* contexts not yet implemented */
  assert (Config->ContextsSeen == NULL);

  fwrite ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
  fwrite ((char *) Config->Protos, sizeof (uinT32),
    Config->ProtoVectorSize, File);

}                                /* WriteTempConfig */