Les opérateurs mathématiques *, /, +, -, ^ peuvent-ils être utilisés pour convertir un nombre différent de zéro en 1?

Je travaille avec le logiciel (Oracle Siebel) qui ne supporte que des expressions JavaScript avec les opérateurs se multiplient, se divisent, soustraient, ajouter et XOR ( *, /, -, +, ^). Je n'ai pas d'autres opérateurs tels que !ou ? :disponibles.

En utilisant les opérateurs ci-dessus, est-il possible de convertir un nombre en 1 s'il est différent de zéro et de le laisser 0 s'il est déjà nul? Le nombre peut être positif, zéro ou négatif.

Exemple:

var c = 55;

var d;  // d needs to set as 1

J'ai essayé c / c, mais il évalue NaNquand cest 0. ddoit être 0 quand cest 0.

c est une valeur monétaire, et il aura un maximum de deux chiffres de fin et 12 chiffres de tête.

J'essaie d'émuler une ifcondition en convertissant un nombre en un booléen 0 ou 1, puis en multipliant d'autres parties de l'expression.

c / (c + 5e-324)devrait marcher. (La constante 5e-324est Number.MIN_VALUE, le plus petit nombre positif représentable.) Si x est 0, c'est exactement 0, et si x est différent de zéro (techniquement, si x est au moins 4,45014771701440252e-308, quel est le plus petit nombre différent de zéro autorisé dans le question, 0.01, est), les calculs en virgule flottante de JavaScript sont trop imprécis pour que la réponse soit différente de 1, donc elle sera exactement 1.

Utilisez l'expression n/n^0.

Si nn'est pas zéro:

 Step    Explanation
------- -------------------------------------------------------------------------------
 n/n^0   Original expression.
 1^0     Any number divided by itself equals 1. Therefore n/n becomes 1.
 1       1 xor 0 equals 1.

Si nvaut zéro:

 Step    Explanation
------- -------------------------------------------------------------------------------
 n/n^0   Original expression.
 0/0^0   Since n is 0, n/n is 0/0.
 NaN^0   Zero divided by zero is mathematically undefined. Therefore 0/0 becomes NaN.
 0^0     In JavaScript, before any bitwise operation occurs, both operands are normalized.
         This means NaN becomes 0.
 0       0 xor 0 equals 0.

Comme vous pouvez le voir, toutes les valeurs non nulles sont converties en 1 et 0 reste à 0. Cela tire parti du fait qu'en JavaScript, NaN^0est 0.

Démo:

[0, 1, 19575, -1].forEach(n => console.log(`${n} becomes ${n/n^0}.`))

(((c/c)^c) - c) * (((c/c)^c) - c) renverra toujours 1 pour les négatifs et les positifs et 0 pour 0.

C'est certainement plus déroutant que la réponse choisie et plus longue. Cependant, j'ai l'impression que c'est moins hacky et ne repose pas sur des constantes.

EDIT: Comme le mentionne @JosephSible, une version plus compacte de la mienne et de la version de @ CRice qui n'utilise pas de constantes est:

c/c^c-c

Une réponse très compliquée, mais qui ne dépend pas d'une précision limitée: si vous prenez x^(2**n), ce sera toujours égal à x+2**nsi x est nul, mais ce sera égal à x-2**nsi x a un un à la nième place. Ainsi, pour x = 0, (x^(2**n)-x+2**n)/(2**(n+1)sera toujours 1, mais il sera parfois nul pour x! = 0. Donc, si vous prenez le produit de (x^(2**n)-x+2**n)/(2**(n+1)sur tout n, puis XOR avec 1, vous obtiendrez la fonction souhaitée. Vous devrez cependant coder manuellement chaque facteur. Et vous devrez le modifier si vous utilisez des virgules flottantes.

Si vous avez l' ==opérateur, puis (x==0)^1fonctionne.