Monthly Archives: April 2011

Code of the day: C, Get the Digits from a Number

Posted by on April 26, 2011 No comments

Today’s Code of the Day is about how to find the digit of a number at a given position. I decided to go with the C / C++ programming languages to time, but you can easily translate the algorithms to other languages.

C Code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
#include <math.h>
 
// Function: getDigitFromNum returns a digit at a given index of a integer.
// Goes from right to left with the starting index of 0.
int getDigitFromNum( int num, int digit ){
    num /= pow( 10, digit );
    return num % 10;
}
// Function: getDigitFromDec returns a digit at a given index of a double.
// Goes from left to right with the starting index of 0.
int getDigitFromDec( double dec, int digit ){
    dec *= pow( 10, digit );
    return (int)dec % 10;
}
// Function: getDigitFromNum returns the decimal values of a double.
double getDecimals( double dec ){
    return dec - (int)dec;
}

Example:
Input File

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Programmed by Larry Battle, bateru.com/news
// Date: April 26, 2011
// Purpose: To demonstrate how to get a digit by a position index.
#include <stdio.h>
#include <math.h>
 
int getDigitFromNum( int num, int digit ){
    num /= pow( 10, digit );
    return num % 10;
}
int getDigitFromDec( double dec, int digit ){
    dec *= pow( 10, digit );
    return ((int)dec) % 10;
}
double getDecimals( double dec ){
    return dec - (int)dec;
}
 
void main(){
    double dec = 1234.56789;
    printf( "\n%d", getDigitFromNum( (int)dec, 0 ));
    printf( "\n%d", getDigitFromDec( dec, 2 ));
    printf( "\n%f", getDecimals( dec ));
}

Output:

1
2
3

4
6
0.567890

Code of the Day: Javascript Fibonacci Numbers the fast way

Posted by on April 18, 2011 No comments 
1
2
3
4
5
6
7
8

//Programmer: Larry Battle
//Date: April 18, 2011
//Purpose: Get Fibonacci numbers in O(1) time.
var getFibonacciNum = function( n ){
    var s5 = Math.sqrt(5);
    var phi1 = (1+s5)/2, phi2 = (1-s5)/2;
    return Math.round((Math.pow( phi1, n ) - Math.pow( phi2, n) )/s5);
};

Demo: Here
Output for 0 to 4

F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3

Learn Sig Figs in No Time

Posted by on April 10, 2011 No comments

Hey Everybody,
I made a video for one of my old post, What are Sig Figs? Tutorial
Enjoy. :)

Code of the Day: Javascript Significant Figures

Posted by on April 7, 2011 No comments

Did you know that JavaScript automatically trims off trailing zeros on numbers with decimals?
Well now you do, and in order to save precision you must wrap the number inside a string.
Example:

1
2
3
4
5
6

var a = "0.0100";
var b = 0.0100;                           // To save space the interpreter cuts off the last two zeros.
console.log( a === b.toString() );	// displays false because a = "0.0100" and b = 0.01
 
console.log( 1000 === 1000.000 );	// displays true
console.log( 0.1 === 0.1000 );		// displays true

Some might argue that you can use num.toPrecision() to save the trailing zeros. But what most are unaware of is that toPrecision() returns a string.

1
2
3
4
5

var num = (120.0).toPrecision(8);
console.log( num );                      // displays 120.00000
console.log( typeof num );            // displays string
console.log( +num );                    // displays 120
// +num is a shortcut for parseInt( num, 10);

Now let’s see what happens with leading zero’s.

1
2
3
4
5
6
7

//A leading 0 in front of a number converts it base 8.
// a.k.a. parseInt( num, 8);
console.log(0011);		// Displays 9
console.log( 010.1000 );		// Error! Octals can only be whole numbers.
console.log( 00000.1000 );	// Error for the same reason.
// The problem is that a leading zero will cause the number to be converted to octal.
// Thus, an error is generated because the decimal point is neither an operation nor semicolon.

Using numbers as strings can be useful when trying to find the Significant Digits, like in the following function.

1
2
3
4
5
6
7
8
9
10
11
12

//Function: getSigFigFromNum( num ), provides the significant digits of a number.
//@num must be a number (base 10) that is a string. example "01"
var getSigFigFromNum = function( num ){
	if( isNaN( +num ) ){
		throw new Error( "getSigFigFromNum(): num (" + num + ") is not a number." );
	}
	// We need to get rid of the leading zeros for the numbers.
	num = num.replace( /^0+/, '');  
	// re is a RegExp to get the numbers from first non-zero to last non-zero
	var re = /[^0](\d*[^0])?/;	
	return ( /\./.test( num ) )? num.length - 1 : (num.match( re ) || [''])[0].length;
};

Usage:

1

getSigFigFromNum( "0.01230" );		//returns 4

DEMO: http://jsbin.com/okide4

Can you think of any other useful examples for number wrapped in strings?

Bad Behavior has blocked 1085 access attempts in the last 7 days.

FireStats icon Powered by FireStats