import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.io.*;

public class Float754 extends JApplet {

    JTextField inputFloatField;
    JTextField inputSignField;
    JTextField inputExponentField;
    JTextField inputMantissaField;
    JLabel errorLabel;

    public void init() {
	Container container = getContentPane();
	int panelRowsSize = 3;
	container.setLayout( new GridLayout( panelRowsSize, 1 ) );

	JPanel [] panelRows = new JPanel[panelRowsSize];
	for (int i=0; i<panelRowsSize; i++) {
	    panelRows[i] = new JPanel();
	    panelRows[i].setLayout( new FlowLayout() );
	    container.add( panelRows[i] );
	}

	Font bigFont = new Font( "Monospaced", Font.BOLD, 16 );

	JLabel inputFloatLabel = new JLabel( "float" );
	inputFloatLabel.setFont( bigFont );
	panelRows[0].add( inputFloatLabel );

	inputFloatField = new JTextField( 15 );
	inputFloatField.setFont( bigFont );
	panelRows[0].add( inputFloatField );
	inputFloatField.addActionListener( 
        	new ActionListener () {
		    public void actionPerformed( ActionEvent event ) {
			
			errorLabel.setText( "" );

			float fnum=0;
			boolean goodNum = true;
			try {
			    fnum = Float.parseFloat( inputFloatField.getText() );
			} catch (NumberFormatException e) {
			    errorLabel.setText( "gack! try again" );
			    goodNum = false;
			}
			if ( goodNum ) {
			    //convert float bits to int bits so can shift and &
			    //
			    int num=0;
			    ByteArrayOutputStream outBuf;
			    ByteArrayInputStream inBuf;
			    DataOutputStream outDataStream;
			    DataInputStream inDataStream;
			    try {
				outBuf = new ByteArrayOutputStream();
				outDataStream = new DataOutputStream( outBuf );
				outDataStream.writeFloat( fnum );
				outDataStream.close();
				byte[] b = new byte[4];
				b = outBuf.toByteArray();
				inBuf = new ByteArrayInputStream( b );
				inDataStream = new DataInputStream( inBuf );
				num = inDataStream.readInt();
				inDataStream.close();
			    } catch (IOException e) {}
			    
			    inputSignField.setText( "" + ((num>>31)&1) );
			    String result="";
			    for (int i=30; i>=23; i--)
				result += ((num>>i) & 1);
			    inputExponentField.setText( result );
			    result = "";
			    for (int i=22; i>=0; i--)
			        result += ((num>>i) & 1);
			    inputMantissaField.setText( result );
			}
			
		    }
		}
		);



	inputSignField = new JTextField( 2 ); //only 1 needed, but looks better
	inputSignField.setFont( bigFont );
	panelRows[1].add( inputSignField );
	TextFieldHandler signFieldHandler = new TextFieldHandler();
	inputSignField.addActionListener( signFieldHandler );

	inputExponentField = new JTextField( 9 );
	inputExponentField.setFont( bigFont );
	panelRows[1].add( inputExponentField );
	inputExponentField.addActionListener( signFieldHandler );

	inputMantissaField = new JTextField( 24 );
	inputMantissaField.setFont( bigFont );
	panelRows[1].add( inputMantissaField );
	inputMantissaField.addActionListener( signFieldHandler );


	errorLabel = new JLabel( "" );
	errorLabel.setFont( bigFont );
	panelRows[2].add( errorLabel );

    }


    public void start() {
	inputFloatField.requestFocusInWindow();
    }

    private class TextFieldHandler implements ActionListener {
        public void actionPerformed( ActionEvent event ) {

	    errorLabel.setText( "" );

	    if ( inputSignField.getText().length() != 1 ||
		 inputExponentField.getText().length() != 8 ||
		 inputMantissaField.getText().length() != 23 )

		      errorLabel.setText( "Must be 1, 8, and 23 bits" );

	    else {
		char c;
		int num = 0; 
		float fnum=0;

		c = inputSignField.getText().charAt( 0 );
		if ( c == '1' )
		    num = (1<<31) | num;

		for (int i=30; i>=23; i--) {
		    c = inputExponentField.getText().charAt( 31-1-i );
		    int j = c=='0' ? 0 : 1;
		    num = (j<<i) | num;
		}

		for (int i=22; i>=0; i--) {
		    c = inputMantissaField.getText().charAt( 31-9-i );
		    int j = c=='0' ? 0 : 1;
		    num = (j<<i) | num;
		}

		ByteArrayOutputStream outBuf;
		ByteArrayInputStream inBuf;
		DataOutputStream outDataStream;
		DataInputStream inDataStream;
		try {
		    outBuf = new ByteArrayOutputStream();
		    outDataStream = new DataOutputStream( outBuf );
		    outDataStream.writeInt( num );
		    outDataStream.close();
		    byte[] b = new byte[4];
		    b = outBuf.toByteArray();
		    inBuf = new ByteArrayInputStream( b );
		    inDataStream = new DataInputStream( inBuf );
		    fnum = inDataStream.readFloat();
		    inDataStream.close();
		} catch (IOException e) {}
		
		inputFloatField.setText( "" + fnum );
		
	    }
	}
    }
    
    
    
}

/*  display bits of a float
    and
    input bit pattern and display float value */

/* Between each power of 2 there are 2^23 evenly spaced floats
   (spaced 1/2^24 * 2^exp apart)   thus eg. there are 2^23 floats
   between 1/2 and 1 and also 2^23 floats between 1 and 2 and between
   128 and 256  and between 4096 and 8192 and between 1/128 and 1/64 etc.
   Floats are uniformly distributed between powers of 2. but
   Half of the (positive) floats are between 0 and 1
   0 is actually roughly 2^-127 (mantissa of all 0)
   Largest is roughly 2^127   */
/* several bit patterns are nan
   some are Inf */

/* investigate -0:  acts like a negative number: -0*5=-0, -0*-0=0 -0=0
    printf("-0=%f -0*-0=%f   -0*5=%f  -0==0? %d\n",f,f*f,f*5,f==0);
*/

    //printf("%f  %9.7f %e  %ul %ul\n",f,f,f,(unsigned long int)f,*p);




/*
enter a float: 0
0.000000  0.0000000 0.000000e+00  0 0
00000000000000000000000000000000

enter a float: -0
-0.000000  -0.0000000 -0.000000e+00  0 -2147483648
10000000000000000000000000000000

enter a float: 1
1.000000  1.0000000 1.000000e+00  1 1065353216
00111111100000000000000000000000

enter a float: 2
2.000000  2.0000000 2.000000e+00  2 1073741824
01000000000000000000000000000000

enter a float: 4
4.000000  4.0000000 4.000000e+00  4 1082130432
01000000100000000000000000000000

enter a float: 15
15.000000  15.0000000 1.500000e+01  15 1097859072
01000001011100000000000000000000

enter a float: .5
0.500000  0.5000000 5.000000e-01  0 1056964608
00111111000000000000000000000000

enter a float: .25
0.250000  0.2500000 2.500000e-01  0 1048576000
00111110100000000000000000000000

enter a float: .375
0.375000  0.3750000 3.750000e-01  0 1052770304
00111110110000000000000000000000


enter 32 bits:
00000000000000000000000000000001
0.000000  0.0000000  1.401298e-45 0 1

enter 32 bits:
01111111111111111111111111111111
NaN        NaN  NaN 2147483647 2147483647

enter 32 bits:
01111111011111111111111111111111
340282346638528859811704183484516925440.000000  340282346638528859811704183484516925440.0000000  3.402823e+38 2147483647 2139095039

enter 32 bits:
10000000000000000000000000000001
-0.000000  -0.0000000  -1.401298e-45 0 -2147483647

enter 32 bits:
11111111111111111111111111111111
-NaN       -NaN  -NaN -2147483648 -1

enter 32 bits:
01111111100000000000000000000000
Inf        Inf  Inf 2147483647 2139095040


sum of 1/2^i i=1,n  is 1 - 1/2^n

Lots of precision:
enter 32 bits:                          1 - 1/2^24  = 1 - 1/16M
00111111011111111111111111111111
1.000000  0.999999940395355224609375000  9.999999e-01 0 1065353215

enter 32 bits:                          2 - 1/2^23
00111111111111111111111111111111
2.000000  1.999999880790710449218750000  2.000000e+00 1 1073741823
 */