# JavaScript/Numbers

JavaScript implements numbers as floating point values, that is, they're attaining decimal values as well as whole number values.

## Basic useEdit

To make a new number, a simple initialization suffices:

```
var foo = 0; // or whatever number you want
```

After you have made your number, you can then modify it as necessary. Numbers can be modified or assigned using the operators defined within JavaScript.

```
foo = 1; //foo = 1
foo += 2; //foo = 3 (the two gets added on)
foo -= 2; //foo = 1 (the two gets removed)
```

Number literals define the number value. In particular:

- They appear as a set of digits of varying length.
- Negative literal numbers have a minus sign before the digits.
- Floating point literal numbers contain one decimal point, and may optionally use the e notation with the character e.
- An integer literal may be prepended with "0" to indicate that a number is in base-8. (8 and 9 are not octal digits, and if found, cause the integer to be read in the normal base-10).
- An integer literal may also be found with prefixed "0x" to indicate a hexadecimal number.

## The `Math` objectEdit

Unlike strings, arrays, and dates, numbers in JavaScript aren't objects, so they don't contain any methods that can be accessed by the normal dot notation. Instead the static `Math` object provides usual numeric functions and constants as its methods and properties. As a static object, the Math object does not need to be instantiated in order to use its methods. The methods and properties of the `Math` object are referenced using the *dot operator* in the usual way, for example:

```
var varOne = Math.ceil(8.5);
var varPi = Math.PI;
var sqrt3 = Math.sqrt(3);
```

### MethodsEdit

`ceil(float)`Edit

Returns the least integer greater than the number passed as an argument.

```
var myInt = Math.ceil(90.8);
document.write(myInt); //91;
```

`floor(float)`Edit

Returns the greatest integer less than the number passed as an argument.

```
var myInt = Math.floor(90.8);
document.write(myInt); //90;
```

`max(int1, int2)`Edit

Returns the highest number from the two numbers passed as arguments.

```
var myInt = Math.max(8, 9);
document.write(myInt); //9
```

`min(int1, int2)`Edit

Returns the lowest number from the two numbers passed as arguments.

```
var myInt = Math.min(8, 9);
document.write(myInt); //8
```

`random()`Edit

Generates a pseudo-random number.

```
var myInt = Math.random();
```

`round(float)`Edit

Returns the closest integer to the number passed as an argument.

```
var myInt = Math.round(90.8);
document.write(myInt); //91;
```

`parseInt() and parseFloat()`Edit

parseInt() and parseFloat() are JavaScript functions that convert strings into numbers. If these functions are given a string of alphabetic characters (A-Z or a-z) to convert, then they both return **NaN**, meaning Not a Number.

```
var x = parseInt("7.5") + 4;
console.log(x); //7 + 4 = 11.
var y = parseFloat("2.8") + 3;
console.log(y); //2.8 + 3 = 5.8.
var z = parseInt("Cat");
console.log(z); // NaN
```

### PropertiesEdit

Properties of the `Math` object are most commonly used constants or functions:

`E:`Returns the constant e.`PI:`Returns the value of pi.`LN10:`Returns the natural logarithm of 10.`LN2:`Returns the natural logarithm of 2.`SQRT2:`Returns the square root of 2.