¿Cómo puedo hacer que sin, cos y tan para usar grados en lugar de radianes?

Cuando trabajo con matemáticas en JS, me gustaría que sus funciones trigonométricas usen valores de grado en lugar de valores en radianes. ¿Como podría hacerlo?

Puede usar una función como esta para hacer la conversión:

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

Tenga en cuenta que funciones como sin, cosy así sucesivamente no devuelven ángulos , toman ángulos como entrada. Me parece que sería más útil para usted tener una función que convierta una entrada de grado a radianes, como esta:

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

que podrías usar para hacer algo como tan(toRadians(45)).

Multiplique la entrada por Math.PI/180para convertir de grados a radianes antes de llamar a las funciones de activación del sistema.

También puede definir sus propias funciones:

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

y así.

Creé mi propio pequeño objeto matemático perezoso para el título (MathD), espero que ayude:

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

/**
 * Converts radian to degree
 * @param radians
 * @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){
        return roundNumber(Math.sin(toRadians(number)));
    },
    cos: function(number){
        return roundNumber(Math.cos(toRadians(number)));
    },
    tan: function(number){
        return roundNumber(Math.tan(toRadians(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)));
   }
};

Me gusta un enfoque funcional más general:

/**
* 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);

o,

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

que se puede utilizar con cualquier función de toma de radianes:

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

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

¡Espero que esto ayude!

Cree su propia función de conversión que aplique las matemáticas necesarias e invoque esas en su lugar. http://en.wikipedia.org/wiki/Radian#Conversion_between_radians_and_degrees