Contexte

Quaternion est un système numérique qui étend les nombres complexes. Un quaternion a la forme suivante

où sont des nombres réels et sont trois unités quaternion fondamentales . Les unités ont les propriétés suivantes:$a,b,c,d$$i,j,k$

Notez que la multiplication par quaternion n'est pas commutative .

Tâche

Étant donné un quaternion non réel , calculez au moins une de ses racines carrées.

Comment?

Selon cette réponse Math.SE , nous pouvons exprimer tout quaternion non réel sous la forme suivante:

où sont des nombres réels et est le vecteur d'unité imaginaire sous la forme avec . Un tel a la propriété , il peut donc être considéré comme l'unité imaginaire.$a,b$$\vec{u}$$xi + yj + zk$$x^2 + y^2 + z^2 = 1$$\vec{u}$$\vec{u}^2 = -1$

Alors le carré de ressemble à ceci:$q$

Inversement, étant donné un quaternion , nous pouvons trouver la racine carrée de en résolvant les équations suivantes$q' = x + y\vec{u}$$q'$

qui est identique au processus de recherche de la racine carrée d'un nombre complexe.

Notez qu'un nombre réel négatif a une infinité de racines carrées de quaternion, mais un quaternion non réel n'a que deux racines carrées .

Entrée et sortie

L'entrée est un quaternion non réel. Vous pouvez le prendre comme quatre nombres réels (virgule flottante), dans l'ordre et la structure de votre choix. Non réel signifie qu'au moins l'un des est non nul.$b,c,d$

La sortie est un ou deux quaternions qui, lorsqu'ils sont au carré, sont égaux à l'entrée.

Cas de test

   Input (a, b, c, d)  =>  Output (a, b, c, d) rounded to 6 digits

 0.0,  1.0,  0.0,  0.0 =>  0.707107,  0.707107,  0.000000,  0.000000
 1.0,  1.0,  0.0,  0.0 =>  1.098684,  0.455090,  0.000000,  0.000000
 1.0, -1.0,  1.0,  0.0 =>  1.168771, -0.427800,  0.427800,  0.000000
 2.0,  0.0, -2.0, -1.0 =>  1.581139,  0.000000, -0.632456, -0.316228
 1.0,  1.0,  1.0,  1.0 =>  1.224745,  0.408248,  0.408248,  0.408248
 0.1,  0.2,  0.3,  0.4 =>  0.569088,  0.175720,  0.263580,  0.351439
99.0,  0.0,  0.0,  0.1 =>  9.949876,  0.000000,  0.000000,  0.005025

Généré à l'aide de ce script Python . Une seule des deux bonnes réponses est spécifiée pour chaque cas de test; l'autre est la négation des quatre valeurs.

Critère de notation et de victoire

Les règles de code-golf standard s'appliquent. Le programme ou la fonction la plus courte en octets dans chaque langue gagne.

APL (NARS) , 2 octets

√

NARS a un support intégré pour les quaternions. ¯ \ _ (⍨) _ / ¯

Python 2 , 72 octets

def f(a,b,c,d):s=((a+(a*a+b*b+c*c+d*d)**.5)*2)**.5;print s/2,b/s,c/s,d/s

Essayez-le en ligne!

Plus ou moins une formule brute. J'ai pensé que je pourrais utiliser des listes de compréhension pour boucler b,c,d, mais cela semble être plus long. Python est vraiment blessé ici par un manque d'opérations vectorielles, en particulier la mise à l'échelle et la norme.

Python 3 , 77 octets

def f(a,*l):r=a+sum(x*x for x in[a,*l])**.5;return[x/(r*2)**.5for x in[r,*l]]

Essayez-le en ligne!

La résolution directe du quadratique était également plus courte que l'utilisation de la racine carrée de nombre complexe de Python pour le résoudre comme dans l'énoncé du problème.

Wolfram Language (Mathematica) , 19 octets

Sqrt
<<Quaternions`

Essayez-le en ligne!

Mathematica intègre également Quaternion, mais est plus détaillé.

_{Bien que les intégrés aient l'air cool, faites des solutions de vote positif qui n'utilisent pas trop les intégrés! Je ne veux pas que les votes sur les questions qui parviennent à HNQ soient faussés.}

JavaScript (ES7), 55 53 octets

Basé sur la formule directe utilisée par xnor .

Prend l'entrée comme un tableau.

q=>q.map(v=>1/q?v/2/q:q=((v+Math.hypot(...q))/2)**.5)

Essayez-le en ligne!

Comment?

$q=[a,b,c,d]$

Et retourne:

q =>                            // q[] = input array
  q.map(v =>                    // for each value v in q[]:
    1 / q ?                     //   if q is numeric (2nd to 4th iteration):
      v / 2 / q                 //     yield v / 2q
    :                           //   else (1st iteration, with v = a):
      q = (                     //     compute x (as defined above) and store it in q
        (v + Math.hypot(...q))  //     we use Math.hypot(...q) to compute:
        / 2                     //       (q[0]**2 + q[1]**2 + q[2]**2 + q[3]**2) ** 0.5
      ) ** .5                   //     yield x
  )                             // end of map()

Haskell , 51 octets

f(a:l)|r<-a+sqrt(sum$(^2)<$>a:l)=(/sqrt(r*2))<$>r:l

Essayez-le en ligne!

Une formule directe. L'astuce principale pour exprimer la partie réelle de la sortie en r/sqrt(r*2)parallèle à l'expression de la partie imaginaire, ce qui économise quelques octets sur:

54 octets

f(a:l)|s<-sqrt$2*(a+sqrt(sum$(^2)<$>a:l))=s/2:map(/s)l

Essayez-le en ligne!

Fusain , 32 octets

≔Ｘ⊗⁺§θ⁰ＸΣＥθ×ιι·⁵¦·⁵η≧∕ηθ§≔θ⁰⊘ηＩθ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Port de la réponse Python @ xnor. Explication:

≔Ｘ⊗⁺§θ⁰ＸΣＥθ×ιι·⁵¦·⁵η

$| x + y\vec{u} | = \sqrt{ x^2 + y^2 } = \sqrt{ (a^2 - b^2)^2 + (2ab)^2 } = a^2 + b^2$$x$$2a^2$$2a$

≧∕ηθ

$y = 2ab$$b$$2a$

§≔θ⁰⊘η

$2a$

Ｉθ

Convertissez les valeurs en chaîne et imprimez implicitement.

Java 8, 84 octets

(a,b,c,d)->(a=Math.sqrt(2*(a+Math.sqrt(a*a+b*b+c*c+d*d))))/2+" "+b/a+" "+c/a+" "+d/a

Port de la réponse Python 2 de @xnor .

Essayez-le en ligne.

Explication:

(a,b,c,d)->           // Method with four double parameters and String return-type
  (a=                 //  Change `a` to:
     Math.sqrt(       //   The square root of:
       2*             //    Two times:
         (a+          //     `a` plus,
          Math.sqrt(  //     the square-root of:
            a*a       //      `a`  squared,
            +b*b      //      `b` squared,
            +c*c      //      `c` squared,
            +d*d))))  //      And `d` squared summed together
  /2                  //  Then return this modified `a` divided by 2
  +" "+b/a            //  `b` divided by the modified `a`
  +" "+c/a            //  `c` divided by the modified `a`
  +" "+d/a            //  And `d` divided by the modified `a`, with space delimiters

05AB1E , 14 octets

nOtsн+·t©/¦®;š

Port de la réponse Python 2 de @xnor .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

n                 # Square each number in the (implicit) input-list
 O                # Sum them
  t               # Take the square-root of that
   sн+            # Add the first item of the input-list
      ·           # Double it
       t          # Take the square-root of it
        ©         # Store it in the register (without popping)
         /        # Divide each value in the (implicit) input with it
          ¦       # Remove the first item
           ®;     # Push the value from the register again, and halve it
             š    # Prepend it to the list (and output implicitly)

Wolfram Language (Mathematica) , 28 octets

{s=#+Norm@{##},##2}/(2s)^.5&

Port de la réponse @ xnor Python 2 .

Essayez-le en ligne!

C # .NET, 88 octets

(a,b,c,d)=>((a=System.Math.Sqrt(2*(a+System.Math.Sqrt(a*a+b*b+c*c+d*d))))/2,b/a,c/a,d/a)

Port de ma réponse Java 8 , mais renvoie un tuple au lieu d'une chaîne. Je pensais que cela aurait été plus court, mais malheureusement, cela Math.Sqrtnécessite une Systemimportation en C # .NET, se terminant par 4 octets de plus au lieu de 10 octets de plus ..>.>

La déclaration lambda a l'air assez drôle, cependant:

System.Func<double, double, double, double, (double, double, double, double)> f =

Essayez-le en ligne.

Perl 6 , 49 octets

{;(*+@^b>>².sum**.5*i).sqrt.&{.re,(@b X/2*.re)}}

Essayez-le en ligne!

Fonction curry prenant l'entrée comme f(b,c,d)(a). Renvoie le quaternion sous la forme a,(b,c,d).

Explication

{;                                             }  # Block returning WhateverCode
     @^b>>².sum**.5     # Compute B of quaternion written as q = a + B*u
                        # (length of vector (b,c,d))
  (*+              *i)  # Complex number a + B*i
                      .sqrt  # Square root of complex number
                           .&{                }  # Return
                              .re,  # Real part of square root
                                  (@b X/2*.re)  # b,c,d divided by 2* real part