# javascript – How can I get sin, cos, and tan to use degrees instead of radians?-ThrowExceptions

Exception or error:

When I’m working with math in JS I would like its trig functions to use degree values instead of radian values. How would I do that?

How to solve:

You can use a function like this to do the conversion:

``````function toDegrees (angle) {
return angle * (180 / Math.PI);
}
``````

Note that functions like `sin`, `cos`, and so on do not return angles, they take angles as input. It seems to me that it would be more useful to you to have a function that converts a degree input to radians, like this:

``````function toRadians (angle) {
return angle * (Math.PI / 180);
}
``````

which you could use to do something like `tan(toRadians(45))`.

###

Multiply the input by `Math.PI/180` to convert from degrees to radians before calling the system trig functions.

You could also define your own functions:

``````function sinDegrees(angleDegrees) {
return Math.sin(angleDegrees*Math.PI/180);
};
``````

and so on.

###

I created my own little lazy Math-Object for degree (MathD), hope it helps:

``````//helper
/**
* @param degree
* @returns {number}
*/
var toRadians = function (degree) {
return degree * (Math.PI / 180);
};

/**
* @returns {number}
*/
var toDegree = function (radians) {
return radians * (180 / Math.PI);
}

/**
* Rounds a number mathematical correct to the number of decimals
* @param number
* @param decimals (optional, default: 5)
* @returns {number}
*/
var roundNumber = function(number, decimals) {
decimals = decimals || 5;
return Math.round(number * Math.pow(10, decimals)) / Math.pow(10, decimals);
}
//the object
var MathD = {
sin: function(number){
},
cos: function(number){
},
tan: function(number){
},
asin: function(number){
return roundNumber(toDegree(Math.asin(number)));
},
acos: function(number){
return roundNumber(toDegree(Math.acos(number)));
},
atan: function(number){
return roundNumber(toDegree(Math.atan(number)));
}
};
``````

###

I like a more general functional approach:

``````/**
* converts a trig function taking radians to degrees
* @param {function} trigFunc - eg. Math.cos, Math.sin, etc.
* @param {number} angle - in degrees
* @returns {number}
*/
const dTrig = (trigFunc, angle) => trigFunc(angle * Math.PI / 180);
``````

or,

``````function dTrig(trigFunc, angle) {
return trigFunc(angle * Math.PI / 180);
}
``````

which can be used with any radian-taking function:

``````dTrig(Math.sin, 90);
// -> 1

dTrig(Math.tan, 180);
// -> 0
``````

Hope this helps!

###

###

If you want to have all radian values be converted to corresponding angles in the unit circle (0 degrees <= angle < 360 degrees), you can first modular the angle in radians by 2 * pi and then do the radians to degrees conversion. The same conversion can be achieved in degrees to radians conversion as well and the code is not shown here.

`````` let radToDeg = function(rad) {
let pi = Math.PI;
let smallRad = rad % (2 * pi); // reduce the radians value to be within the unit circle or from 0 to 2 * pi
let deg = smallRad / (pi) * 180; // normal radians to degrees conversion factor
let errorBound = 1e-6; // error tolerance
if (Math.abs(deg - Math.round(deg)) <= errorBound){
return Math.round(deg);
} else{
return deg;
}
}
``````

To achieve higher precision in the calculation, Javascript’s builtin modular (%) operator should be avoided. The following code is basically a copy of the unit circle. However, all angles are converted to their corresponding values in the unit circle. For example, 7.330382858376184 (or pi / 3 + 2 * pi) is converted to 60 degrees; 74774.09394564186 (or -2 * pi / 3 + 23802 * pi) is converted to 240 degrees.

``````let radToDeg = function(rad) {
let pi = Math.PI;
if (evenlyDivide(rad, 2 * pi)) {
return 0;
} else if (evenlyDivide(rad, pi)) {
return 180;
} else if (evenlyDivide(rad - pi / 2, 2 * pi)){
return 90;
} else if (evenlyDivide(rad + pi / 2, 2 * pi)){
return 270;
} else if (evenlyDivide(rad - pi / 4, 2 * pi)){
return 45;
} else if (evenlyDivide(rad + pi / 4, 2 * pi)){
return 315;
} else if (evenlyDivide(rad - pi / 6, 2 * pi)){
return 30;
} else if (evenlyDivide(rad + pi / 6, 2 * pi)){
return 330;
} else if (evenlyDivide(rad - pi / 3, 2 * pi)){
return 60;
} else if (evenlyDivide(rad + pi / 3, 2 * pi)){
return 300;
} else if (evenlyDivide(rad - 2 * pi / 3, 2 * pi)){
return 120;
} else if (evenlyDivide(rad + 2 * pi / 3, 2 * pi)){
return 240;
} else if (evenlyDivide(rad - 3 * pi / 4, 2 * pi)){
return 135;
} else if (evenlyDivide(rad + 3 * pi / 4, 2 * pi)){
return 225;
} else if (evenlyDivide(rad - 5 * pi / 6, 2 * pi)){
return 150;
} else if (evenlyDivide(rad + 5 * pi / 6, 2 * pi)){
return 210;
} else{
return smallRad / (pi) * 180;
}
}
``````

And the `evenlyDivide` function is simply checks if the two input values are divisable (result of division of an integer) within some tolerance bounds:

``````let evenlyDivide = function(val, step) {
let divided = val / step; // the result of division of two input values
let errorBound = 1e-7; // error tolerance
if (Math.abs(divided - Math.round(divided)) < errorBound) { // test if within error bound
return true;
}
return false;
}
``````