path: root/nbench1.h

/*
** nbench1.h
** Header for nbench1.c
** BYTEmark (tm)
** BYTE's Native Mode Benchmarks
** Rick Grehan, BYTE Magazine
**
** Creation:
** Revision: 3/95;10/95
**
** DISCLAIMER
** The source, executable, and documentation files that comprise
** the BYTEmark benchmarks are made available on an "as is" basis.
** This means that we at BYTE Magazine have made every reasonable
** effort to verify that the there are no errors in the source and
** executable code.  We cannot, however, guarantee that the programs
** are error-free.  Consequently, McGraw-HIll and BYTE Magazine make
** no claims in regard to the fitness of the source code, executable
** code, and documentation of the BYTEmark.
**  Furthermore, BYTE Magazine, McGraw-Hill, and all employees
** of McGraw-Hill cannot be held responsible for any damages resulting
** from the use of this code or the results obtained from using
** this code.
*/
#include <stdint.h>

/*
** DEFINES
*/
/* #define DEBUG */

/*
** EXTERNALS
*/
extern unsigned long global_min_ticks;

extern SortStruct global_numsortstruct;
extern SortStruct global_strsortstruct;
extern BitOpStruct global_bitopstruct;
extern EmFloatStruct global_emfloatstruct;
extern FourierStruct global_fourierstruct;
extern AssignStruct global_assignstruct;
extern IDEAStruct global_ideastruct;
extern HuffStruct global_huffstruct;
extern NNetStruct global_nnetstruct;
extern LUStruct global_lustruct;

/* External PROTOTYPES */
/*extern unsigned long abs_randwc(unsigned long num);*/     /* From MISC */
/*extern long randnum(long lngval);*/
extern int32_t randwc(int32_t num);
extern uint32_t abs_randwc(uint32_t num);
extern int32_t randnum(int32_t lngval);

extern void *AllocateMemory(unsigned long nbytes,    /* From SYSSPEC */
	int *errorcode);
extern void FreeMemory(void *mempointer,
	int *errorcode);
extern void MoveMemory(void *destination,
		void *source, unsigned long nbytes);
extern void ReportError(char *context, int errorcode);
extern unsigned long StartStopwatch();
extern unsigned long StopStopwatch(unsigned long startticks);
extern unsigned long TicksToSecs(unsigned long tickamount);
extern double TicksToFracSecs(unsigned long tickamount);

/*****************
** NUMERIC SORT **
*****************/

/*
** PROTOTYPES
*/
void DoNumSort(void);
static unsigned long DoNumSortIteration(long *arraybase,
		unsigned long arraysize,
		unsigned int numarrays);
static void LoadNumArrayWithRand(long *array,
		unsigned long arraysize,
		unsigned int numarrays);
static void NumHeapSort(long *array,
		unsigned long bottom,
		unsigned long top);
static void NumSift(long *array,
		unsigned long i,
		unsigned long j);


/****************
** STRING SORT **
*****************
*/


/*
** PROTOTYPES
*/
void DoStringSort(void);
static unsigned long DoStringSortIteration(unsigned char *arraybase,
		unsigned int numarrays,
		unsigned long arraysize);
static unsigned long *LoadStringArray(unsigned char *strarray,
		unsigned int numarrays,
		unsigned long *strings,
		unsigned long arraysize);
static void stradjust(unsigned long *optrarray,
		unsigned char *strarray,
		unsigned long nstrings,
		unsigned long i,
		unsigned char l);
static void StrHeapSort(unsigned long *optrarray,
		unsigned char *strarray,
		unsigned long numstrings,
		unsigned long bottom,
		unsigned long top);
static int str_is_less(unsigned long *optrarray,
		unsigned char *strarray,
		unsigned long numstrings,
		unsigned long a,
		unsigned long b);
static void strsift(unsigned long *optrarray,
		unsigned char *strarray,
		unsigned long numstrings,
		unsigned long i,
		unsigned long j);

/************************
** BITFIELD OPERATIONS **
*************************
*/

/*
** PROTOTYPES
*/
void DoBitops(void);
static unsigned long DoBitfieldIteration(unsigned long *bitarraybase,
		unsigned long *bitoparraybase,
		long bitoparraysize,
		unsigned long *nbitops);
static void ToggleBitRun(unsigned long *bitmap,
		unsigned long bit_addr,
		unsigned long nbits,
		unsigned int val);
static void FlipBitRun(unsigned long *bitmap,
		unsigned long bit_addr,
		unsigned long nbits);

/****************************
** EMULATED FLOATING POINT **
****************************/
typedef struct
{
	uint8_t type;        /* Indicates, NORMAL, SUBNORMAL, etc. */
	uint8_t sign;        /* Mantissa sign */
	short exp;      /* Signed exponent...no bias */
	uint16_t mantissa[INTERNAL_FPF_PRECISION];
} InternalFPF;

/*
** PROTOTYPES
*/
void DoEmFloat(void);

/*
** EXTERNALS
*/
extern void SetupCPUEmFloatArrays(InternalFPF *abase,
	InternalFPF *bbase, InternalFPF *cbase,
	unsigned long arraysize);
extern unsigned long DoEmFloatIteration(InternalFPF *abase,
	InternalFPF *bbase, InternalFPF *cbase,
	unsigned long arraysize, unsigned long loops);

/*************************
** FOURIER COEFFICIENTS **
*************************/

/*
** PROTOTYPES
*/
void DoFourier(void);
static unsigned long DoFPUTransIteration(double *abase,
		double *bbase,
		unsigned long arraysize);
static double TrapezoidIntegrate(double x0,
		double x1,
		int nsteps,
		double omegan,
		int select);
static double thefunction(double x,
		double omegan,
		int select);

/*************************
** ASSIGNMENT ALGORITHM **
*************************/

/*
** DEFINES
*/

#define ASSIGNROWS 101L
#define ASSIGNCOLS 101L

/*
** TYPEDEFS
*/
typedef struct {
	union {
		long *p;
		long (*ap)[ASSIGNROWS][ASSIGNCOLS];
	} ptrs;
} longptr;

/*
** PROTOTYPES
*/
void DoAssign(void);
static unsigned long DoAssignIteration(long *arraybase,
		unsigned long numarrays);
static void LoadAssignArrayWithRand(long *arraybase,
		unsigned long numarrays);
static void LoadAssign(long arraybase[][ASSIGNCOLS]);
static void CopyToAssign(long arrayfrom[][ASSIGNCOLS],
		long arrayto[][ASSIGNCOLS]);
static void Assignment(long arraybase[][ASSIGNCOLS]);
static void calc_minimum_costs(long tableau[][ASSIGNCOLS]);
static int first_assignments(long tableau[][ASSIGNCOLS],
		short assignedtableau[][ASSIGNCOLS]);
static void second_assignments(long tableau[][ASSIGNCOLS],
		short assignedtableau[][ASSIGNCOLS]);

/********************
** IDEA ENCRYPTION **
********************/

/*
** DEFINES
*/
#define IDEAKEYSIZE 16
#define IDEABLOCKSIZE 8
#define ROUNDS 8
#define KEYLEN (6*ROUNDS+4)

/*
** MACROS
*/
#define low16(x) ((x) & 0x0FFFF)
#define MUL(x,y) (x=mul(low16(x),y))


typedef uint16_t IDEAkey[KEYLEN];

/*
** PROTOTYPES
*/
void DoIDEA(void);
static unsigned long DoIDEAIteration(unsigned char *plain1,
	unsigned char *crypt1, unsigned char *plain2,
	unsigned long arraysize, unsigned long nloops,
	IDEAkey Z, IDEAkey DK);
static uint16_t mul(register uint16_t a, register uint16_t b);
static uint16_t inv(uint16_t x);
static void en_key_idea(uint16_t userkey[8], IDEAkey Z);
static void de_key_idea(IDEAkey Z, IDEAkey DK);
static void cipher_idea(uint16_t in[4], uint16_t out[4], IDEAkey Z);

/************************
** HUFFMAN COMPRESSION **
************************/

/*
** DEFINES
*/
#define EXCLUDED 32000L          /* Big positive value */

/*
** TYPEDEFS
*/
typedef struct {
	unsigned char c;                /* Byte value */
	float freq;             /* Frequency */
	int parent;             /* Parent node */
	int left;               /* Left pointer = 0 */
	int right;              /* Right pointer = 1 */
} huff_node;

/*
** GLOBALS
*/
static huff_node *hufftree;             /* The huffman tree */
static long plaintextlen;               /* Length of plaintext */

/*
** PROTOTYPES
*/
void DoHuffman();
static void create_text_line(char *dt,long nchars);
static void create_text_block(char *tb, unsigned long tblen,
		unsigned short maxlinlen);
static unsigned long DoHuffIteration(char *plaintext,
	char *comparray, char *decomparray,
	unsigned long arraysize, unsigned long nloops, huff_node *hufftree);
static void SetCompBit(uint8_t *comparray, uint32_t bitoffset, char bitchar);
static int GetCompBit(uint8_t *comparray, uint32_t bitoffset);

/********************************
** BACK PROPAGATION NEURAL NET **
********************************/

/*
** DEFINES
*/
#define T 1                     /* TRUE */
#define F 0                     /* FALSE */
#define ERR -1
#define MAXPATS 10              /* max number of patterns in data file */
#define IN_X_SIZE 5             /* number of neurodes/row of input layer */
#define IN_Y_SIZE 7             /* number of neurodes/col of input layer */
#define IN_SIZE 35              /* equals IN_X_SIZE*IN_Y_SIZE */
#define MID_SIZE 8              /* number of neurodes in middle layer */
#define OUT_SIZE 8              /* number of neurodes in output layer */
#define MARGIN 0.1              /* how near to 1,0 do we have to come to stop? */
#define BETA 0.09               /* beta learning constant */
#define ALPHA 0.09              /* momentum term constant */
#define STOP 0.1                /* when worst_error less than STOP, training is done */

/*
** GLOBALS
*/
double  mid_wts[MID_SIZE][IN_SIZE];     /* middle layer weights */
double  out_wts[OUT_SIZE][MID_SIZE];    /* output layer weights */
double  mid_out[MID_SIZE];              /* middle layer output */
double  out_out[OUT_SIZE];              /* output layer output */
double  mid_error[MID_SIZE];            /* middle layer errors */
double  out_error[OUT_SIZE];            /* output layer errors */
double  mid_wt_change[MID_SIZE][IN_SIZE]; /* storage for last wt change */
double  out_wt_change[OUT_SIZE][MID_SIZE]; /* storage for last wt change */
double  in_pats[MAXPATS][IN_SIZE];      /* input patterns */
double  out_pats[MAXPATS][OUT_SIZE];    /* desired output patterns */
double  tot_out_error[MAXPATS];         /* measure of whether net is done */
double  out_wt_cum_change[OUT_SIZE][MID_SIZE]; /* accumulated wt changes */
double  mid_wt_cum_change[MID_SIZE][IN_SIZE];  /* accumulated wt changes */

double  worst_error; /* worst error each pass through the data */
double  average_error; /* average error each pass through the data */
double  avg_out_error[MAXPATS]; /* average error each pattern */

int iteration_count;    /* number of passes thru network so far */
int numpats;            /* number of patterns in data file */
int numpasses;          /* number of training passes through data file */
int learned;            /* flag--if TRUE, network has learned all patterns */

/*
** PROTOTYPES
*/
void DoNNET(void);
static unsigned long DoNNetIteration(unsigned long nloops);
static void do_mid_forward(int patt);
static void do_out_forward();
void display_output(int patt);
static void do_forward_pass(int patt);
static void do_out_error(int patt);
static void worst_pass_error();
static void do_mid_error();
static void adjust_out_wts();
static void adjust_mid_wts();
static void do_back_pass(int patt);
static void move_wt_changes();
static int check_out_error();
static void zero_changes();
static void randomize_wts();
static int read_data_file();
/* static int initialize_net(); */

/***********************
**  LU DECOMPOSITION  **
** (Linear Equations) **
***********************/

/*
** DEFINES
*/

#define LUARRAYROWS 101L
#define LUARRAYCOLS 101L

/*
** TYPEDEFS
*/
typedef struct
{       union
	{       double *p;
		double (*ap)[][LUARRAYCOLS];
	} ptrs;
} LUdblptr;

/*
** GLOBALS
*/
double *LUtempvv;

/*
** PROTOTYPES
*/
void DoLU(void);
static void LUFreeMem(double *a, double *b,
	double *abase, double *bbase);
static unsigned long DoLUIteration(double *a, double *b,
	double *abase, double *bbase,
	unsigned long numarrays);
static void build_problem( double a[][LUARRAYCOLS],
	int n, double b[LUARRAYROWS]);
static int ludcmp(double a[][LUARRAYCOLS],
	int n, int indx[], int *d);
static void lubksb(double a[][LUARRAYCOLS],
	int n, int indx[LUARRAYROWS],
	double b[LUARRAYROWS]);
static int lusolve(double a[][LUARRAYCOLS],
	int n, double b[LUARRAYROWS]);