Come posso ottenere sin, cos e tan per usare i gradi invece dei radianti?

Quando lavoro con la matematica in JS, vorrei che le sue funzioni trigonometriche utilizzassero valori in gradi invece di valori in radianti. Come potrei farlo?

Puoi usare una funzione come questa per eseguire la conversione:

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

Si noti che funzioni come sin, cose così via non restituiscono angoli , ma prendono gli angoli come input. Mi sembra che ti sarebbe più utile avere una funzione che converte un input di gradi in radianti, come questa:

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

che potresti usare per fare qualcosa di simile tan(toRadians(45)).

Moltiplicare l'input per Math.PI/180per convertire da gradi a radianti prima di chiamare le funzioni trigonometriche di sistema.

Puoi anche definire le tue funzioni:

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

e così via.

Ho creato il mio piccolo oggetto matematico pigro per la laurea (MathD), spero che aiuti:

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

Mi piace un approccio funzionale più generale:

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

che può essere utilizzato con qualsiasi funzione di rilevamento del radiante:

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

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

Spero che questo ti aiuti!

Crea la tua funzione di conversione che applica la matematica necessaria e invocali invece. http://en.wikipedia.org/wiki/Radian#Conversion_between_radians_and_degrees