web-dev-qa-db-fra.com

Comment puis-je obtenir que péché, cos et bronzage utilise des degrés au lieu de radians?

Lorsque je travaille avec JS en mathématiques, je voudrais que ses fonctions trig utilisent des valeurs en degrés au lieu de valeurs en radians. Comment je ferais ça?

javascriptmath
87
0x499602D2

Vous pouvez utiliser une fonction comme celle-ci pour effectuer la conversion:

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

Notez que des fonctions telles que sin, cos et ainsi de suite ne renvoient pas d'angles , elles prennent des angles en entrée. Il me semble qu’il vous serait plus utile d’avoir une fonction qui convertit une entrée de degré en radians, comme ceci:

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

que vous pourriez utiliser pour faire quelque chose comme tan(toRadians(45)).

189
Peter Olson

Multipliez l'entrée par Math.PI/180 pour convertir les degrés en radians avant d'appeler les fonctions trig du système.

Vous pouvez également définir vos propres fonctions:

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

etc.

24
Niet the Dark Absol

J'ai créé mon propre petit objet mathématique paresseux pour diplôme (MathD), en espérant que cela aide:

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

J'aime une approche fonctionnelle plus générale:

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

ou,

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

qui peut être utilisé avec n'importe quelle fonction de prise de radians:

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

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

J'espère que cela t'aides!

1
David Nishikawa

Si vous souhaitez convertir toutes les valeurs en radians en angles correspondants dans le cercle unitaire (0 degré <= angle <360 degrés), vous pouvez moduler l'angle en radians de 2 * pi, puis convertir les radians en degrés. La même conversion peut être obtenue en degrés en conversion de radians également et le code n’est pas affiché ici.

 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
      // adjust floating point imprecisions
      if (Math.abs(deg - Math.round(deg)) <= errorBound){
        return Math.round(deg);
      } else{
        return deg;
      }
    }

Pour obtenir une précision de calcul supérieure, vous devez éviter l'opérateur modulaire (%) intégré à Javascript. Le code suivant est fondamentalement une copie du cercle d'unités. Cependant, tous les angles sont convertis en leurs valeurs correspondantes dans le cercle unitaire. Par exemple, 7.330382858376184 (ou pi/3 + 2 * pi) est converti en 60 degrés; 74774.09394564186 (ou -2 * pi/3 + 23802 * pi) est converti en 240 degrés.

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{
    let smallRad = rad % (2 * pi);
    return smallRad / (pi) * 180;
  }
}

Et la fonction evenlyDivide vérifie simplement si les deux valeurs d'entrée sont divisibles (résultat de la division d'un entier) dans les limites de tolérance:

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;
}
0
AlienKevin

Créez votre propre fonction de conversion qui applique les calculs nécessaires et appelez-les à la place. http://en.wikipedia.org/wiki/Radian#Conversion_between_radians_and_degrees

0
MLProgrammer-CiM