//
//
//
//

function fix(n,d){
	var zstr = '0000000000000000000000'
	var theInt = ''
	var theFrac = ''
	var theNo = ''
	rfac = ''
	rfacx = 0
	nx = 0
	if ((typeof n) != "string") {
	    n = String(n) ;
	}
	var xt = parseInt(d) + 1
	var rstr = '' + zstr.substring(1,xt)
	var rfac = '.' + rstr + '5'
	var rfacx = parseFloat(rfac)
	var xx = n.indexOf('.')
	var l = n.length
	if (xx == -1 ) 	{    // No fraction
		theFrac = zstr
		theInt = "" + n
	}
	else if (xx == 0) {
		theInt = '0'
		nx = 0 + parseFloat(n) + parseFloat(rfacx)
		n = nx + zstr
		theFrac = '' + n.substring(1, n.length)
	}
	else {
		theInt = n.substring(0,xx)
		nx = parseFloat(n) + rfacx
		n = '' + nx + zstr
		theFrac = '' + n.substring(xx+1,xx + 1 + parseInt(d))
		var astr = 'd = ' + d
	}
	theFrac = theFrac.substring(0,parseInt(d))
	var ii = 0
	theNo = theInt + '.' + theFrac
	return theNo
}

ending = new Array("","0", "00", "000", "0000", "00000", "000000", "0000000", "00000000", "000000000") ;

function round(thing, digit) {
    var pos    ;
    var front  ;
    var pivot  ;
    var end    ;
    var result ;
    
    thing = String(thing) ;
    
    pos   = thing.length - digit  ;
    
    front = thing.substring(0,pos) ;
    pivot = thing.substring(pos,pos+1) ;
    end   = thing.substring(eval(pos),thing.length) ;
 
    if (pivot > 4) {
        front = parseInt(front) + 1 ;
    }  
      
    result = String(front)+ending[digit] ;
    return (parseInt(result)) ;
}

function assert(str) {
    debugging = false ;
    if (debugging == true) {
        document.writeln(str + "<br>") ;
    }
}

//
//                                  fround
//
//  Round a decimal to the specified decimal location.
//
function fround(thing, digit) {
                                                    // 0 = 10, 1 = 100, 2 = 1000, 3 = 10000
    var i                                         ;
    var kicker        = new Array(0, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001,0.00000001) ;
    var fstring       = String(thing)             ;
    var index         = fstring.indexOf(".",0)    ; // location of decimal point.
    var length        = fstring.length            ; // length of input number
    var decimaldigits = length - index - 1        ; // number of digits in input
    var answer        = new Number()              ;
    var criteria      = new Number()              ;
    
    assert("Thing: " + thing + " decimaldigits: " + decimaldigits) ;
    if (index < 0) {
        assert("index < 0") ;
	
        fstring += "."                            ;
	index = fstring.indexOf(".",0)            ;
	length ++                                 ;
	decimaldigits = 0                         ;
    }
    digit ++                                      ; // 1 = 10, 2 = 100, 3 = 1000, 4 = 10000
  
    if (digit < decimaldigits) {
        assert("digit < decimaldigits") ;
	assert("&nbsp;&nbsp;digit: " + digit + ":" + " decimaldigits: " + decimaldigits) ;
	answer = fstring.substring(0,index+digit+2) ; // Get truncated value.
	                                              // Use criteria of next decimal position
						      //   to determine if we must bump by 1. 
						      //
        if (decimaldigits > 15) {
            answer = parseFloat(answer) + parseFloat("0.000000000000001") ;
	    assert("&nbsp;&nbsp;answer: " + answer) ;
	}

	criteria  = parseInt(fstring.substring(index+digit+1,index+digit+2)) ;
        assert("&nbsp;&nbsp;answer: " + answer + " criteria: " + criteria + " index: " + index + " digit: " + digit) ;
	if (criteria > 4) {
	    assert("&nbsp;&nbsp;&nbsp;&nbsp;criteria > 4") ;
	    assert("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" + kicker[digit]) ;
	    
            answer = parseFloat(answer) + parseFloat(kicker[digit]) ;
	} else {
            answer = parseFloat(answer) ;
	}
	fstring = String(answer) ;
	answer = fstring.substring(0,index+digit+1) ;
	assert("&nbsp;&nbsp;&nbsp;&nbsp;answer : " + answer) ;

    } else if (digit == decimaldigits) {
        assert("digit == decimaldigits") ;
	assert("&nbsp;&nbsp;fstring: " + fstring + " index:" + index + " digit: " + digit + " length: " + length ) ;
	answer = fstring                          ; // nothing to do.
    } else {
        assert("digit > decimaldigits") ;
	assert("&nbsp;&nbsp;fstring: " + fstring +  " decimaldigits: " + decimaldigits + " digits: " + digit) ;
        answer = fstring                          ;
	var padding = digit - decimaldigits       ;
        for (i = 0 ; i < padding ; i++) {
	    assert("&nbsp;&nbsp;&nbsp;&nbsp;padding zeros") ;
            answer += "0" ;                         // pad missing zeroes
	}
    }

    return (answer) ;
}