/********************************************************************************/
/*      input: A file containing threshold voltages of each inverter		*/
/*                                                                              */
/*      output: A file telling desirable sizes of inverter to be used in	*/
/*	        a comparator							*/
/*                                                                              */
/*      Date: Mar. 10, 2001                                                     */
/*      By:   Daegyu Lee                                                        */
/*      The Pennsylvania State University                                       */
/*      Department of Computer Science and Engineering                          */
/*      Copyright Daegyu Lee 2001                                               */      
/*      Revision 0.3                                                            */
/********************************************************************************/                            

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

main( int argc, char* argv[] )
{
	int	i, j, numOfBit, numOfInv, numOfSizes, numOfSet;
	int	length_P, width_P, length_N, width_N, minDiffOfVmIndex, maxErrorInvNo;
	int	*pLength, *pWidth, *nLength, *nWidth;
	double	*optVm, *Vm;
	double	beginningVm, endingVm, gapVm, ThresholdV, diffOfVm, minDiffOfVm, diffOfOptSel, ratioOfDiff;
	double	errorRate, maxError, sqrSum;
	FILE	*fp1, *fp2, *fp3;
	char	outFileName1[25], outFileName2[25], numString[5];

	if( argc != 2 )
	{
		printf( "Usage: findSizes Size_VmFile\n" );
		exit( -1 );
	}

	printf( "How many bit = ?" ); scanf( "%d", &numOfBit );
	printf( "Beginning Vm = ?" ); scanf( "%lf", &beginningVm );
	printf( "Ending Vm = ?" ); scanf( "%lf", &endingVm );
	printf( "Set No. = ?" ); scanf( "%d", &numOfSet );

	numOfInv = (int)pow(2, numOfBit)-1;

	optVm = (double *) malloc( numOfInv*sizeof(double) );
	if( optVm == NULL )
	{
		printf( "Memory allocation failed !!\n" );
		exit( -1 );
	}
	
	gapVm =  ((endingVm-beginningVm)/((double)(numOfInv-1.0)));
	for( i=0; i<numOfInv; i++ )
	{
		optVm[i] = beginningVm + (gapVm * (double)(i));
	}

	fp1 = fopen( argv[1], "r" );
	numOfSizes = 0;
	while( fscanf(fp1, "%d %d %d %d %lf", &length_P, &width_P, &length_N, &width_N, &ThresholdV) != EOF )
	{
		numOfSizes++;
	}
	fclose( fp1 );

	Vm = (double *) malloc( numOfSizes*sizeof(double) );
	if( Vm == NULL )
	{
		printf( "Memory allocation failed !!\n" );
		exit( -1 );
	}

        pLength = (int *) malloc( numOfSizes*sizeof(int) );
        if( pLength == NULL )
        {
                printf( "Memory allocation failed !!\n" );
                exit( -1 );
        }

        pWidth = (int *) malloc( numOfSizes*sizeof(int) );
        if( pWidth == NULL )
        {
                printf( "Memory allocation failed !!\n" );
                exit( -1 );
        }

        nLength = (int *) malloc( numOfSizes*sizeof(int) );
        if( nLength == NULL )
        {
                printf( "Memory allocation failed !!\n" );
                exit( -1 );
        }

        nWidth = (int *) malloc( numOfSizes*sizeof(int) );
        if( nWidth == NULL )
        {
                printf( "Memory allocation failed !!\n" );
                exit( -1 );
        }

	fp1 = fopen( argv[1], "r" );
	for( i=0; i<numOfSizes; i++ )
	{
		fscanf( fp1, "%d %d %d %d %lf", &pLength[i], &pWidth[i], &nLength[i], &nWidth[i], &Vm[i] );
	}
	fclose( fp1 );

	sprintf( numString, "%d", numOfBit );
	strcpy( outFileName2, numString );
	strcat( outFileName2, "Bit_SelSetSize.rslt" );

	sprintf( numString, "%d", numOfBit );
	strcpy( outFileName1, numString );
	strcat( outFileName1, "Bit_SelSetReport.rslt" );

	fp2 = fopen( outFileName1, "w" );
	fp3 = fopen( outFileName2, "w" );

	sqrSum = 0.0;
	maxError = 0; maxErrorInvNo = 0;

	fprintf( fp2, " No. Opt. Vm    Selec. Vm  Diff.       Err. rate PL  PW  NL  NW\n" );

	for( i=0; i<numOfInv; i++ )
	{
		minDiffOfVm = sqrt(((optVm[i]+0.0001*numOfSet)-Vm[0])*((optVm[i]+0.0001*numOfSet)-Vm[0]));
		minDiffOfVmIndex = 0;
		for( j=0; j<numOfSizes; j++ )
		{
			diffOfVm = sqrt(((optVm[i]+0.0001*numOfSet)-Vm[j])*((optVm[i]+0.0001*numOfSet)-Vm[j]));
			if( diffOfVm <= minDiffOfVm )
			{
				minDiffOfVm = diffOfVm;
				minDiffOfVmIndex = j;
			}
		}
		sqrSum += ((optVm[i]+0.0001*numOfSet)-Vm[minDiffOfVmIndex])*((optVm[i]+0.0001*numOfSet)-Vm[minDiffOfVmIndex]);
		diffOfOptSel = sqrt(((optVm[i]+0.0001*numOfSet)-Vm[minDiffOfVmIndex])*((optVm[i]+0.0001*numOfSet)-Vm[minDiffOfVmIndex]));
		errorRate = (diffOfOptSel/gapVm)*(double)(100.0);
		if( errorRate > maxError )
		{
			maxError = errorRate;
			maxErrorInvNo = i+1;
		}
		fprintf( fp2, "%3d: %10.8f %10.8f %10.8f %10.7f %d %d %d %d\n", i+1,
		 	(optVm[i]+0.0001*numOfSet), Vm[minDiffOfVmIndex], diffOfOptSel, errorRate, pLength[minDiffOfVmIndex], pWidth[minDiffOfVmIndex],
		 	nLength[minDiffOfVmIndex], nWidth[minDiffOfVmIndex] );

		fprintf( fp3, "%d %d %d %d\n", pLength[minDiffOfVmIndex], pWidth[minDiffOfVmIndex],
						       nLength[minDiffOfVmIndex], nWidth[minDiffOfVmIndex] );
	}

	fprintf( fp2, "-----------------------------------------------------------------------------------\n" ); 
	fprintf( fp2, "Set No.%3d: Square sum = %11.9f, Max. deviation = %10.7f at Inverter No. %d\n", numOfSet, sqrSum, maxError, maxErrorInvNo );

	fclose( fp2 );
	fclose( fp3 );

	free( pLength );
	free( pWidth );
	free( nLength );
	free( nWidth );
	free( optVm );
	free( Vm );
}