Latar Belakang

Quaternion adalah sistem bilangan yang memperluas bilangan kompleks. Angka empat memiliki bentuk berikut

di mana $a,b,c,d$ adalah bilangan real dan $i,j,k$ adalah tiga unit angka empat mendasar . Unit memiliki properti berikut:

Perhatikan bahwa perkalian angka empat tidak komutatif .

Tugas

Dengan angka empat yang tidak nyata , hitung setidaknya satu dari akar kuadratnya.

Bagaimana?

Menurut jawaban Math.SE ini , kami dapat mengekspresikan angka empat yang tidak nyata dalam bentuk berikut:

di mana $a,b$ adalah bilangan real dan $\vec{u}$ adalah vektor satuan imajiner dalam bentuk $xi + yj + zk$ dengan $x^2 + y^2 + z^2 = 1$ . Apapun seperti $\vec{u}$ memiliki properti $\vec{u}^2 = -1$ , sehingga dapat dilihat sebagai satuan imajiner.

Maka kuadrat $q$ terlihat seperti ini:

Sebaliknya, dengan diberi angka empat $q' = x + y\vec{u}$ , kita dapat menemukan akar kuadrat dari $q'$ dengan menyelesaikan persamaan berikut

yang identik dengan proses menemukan akar kuadrat dari bilangan kompleks.

Perhatikan bahwa bilangan real negatif memiliki banyak akar kueriern yang tak terhingga banyaknya, tetapi angka empat yang tidak nyata hanya memiliki dua akar kuadrat .

Masukan dan keluaran

Input adalah angka empat yang tidak nyata. Anda dapat menganggapnya sebagai empat angka nyata (titik mengambang), dalam urutan dan struktur pilihan apa pun. Non-nyata berarti bahwa setidaknya satu dari $b,c,d$ adalah nol.

Output adalah satu atau dua angka empat yang, ketika kuadrat, sama dengan input.

Uji kasus

   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

Dihasilkan menggunakan skrip Python ini . Hanya satu dari dua jawaban yang benar yang ditentukan untuk setiap kasus uji; yang lainnya adalah keempat nilai dinegasikan.

Kriteria penilaian & menang

Aturan standar kode-golf berlaku. Program atau fungsi terpendek dalam byte di setiap bahasa menang.

APL (NARS) , 2 byte

√

NARS memiliki dukungan bawaan untuk angka empat. ¯ \ _ (⍨) _ / ¯

Python 2 , 72 byte

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

Cobalah online!

Lebih atau kurang formula mentah. Saya pikir saya bisa menggunakan daftar untuk mengulang b,c,d, tetapi ini tampaknya lebih lama. Python benar-benar terluka di sini karena kurangnya operasi vektor, khususnya penskalaan dan norma.

Python 3 , 77 byte

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

Cobalah online!

Memecahkan kuadrat secara langsung juga lebih pendek daripada menggunakan akar kuadrat bilangan kompleks Python untuk menyelesaikannya seperti dalam pernyataan masalah.

Bahasa Wolfram (Mathematica) , 19 byte

Sqrt
<<Quaternions`

Cobalah online!

Mathematica memiliki Quaternion built-in juga, tetapi lebih verbose.

_{Meskipun built-in terlihat keren, lakukan solusi peningkatan yang tidak menggunakan built-in juga! Saya tidak ingin suara pada pertanyaan yang mencapai HNQ miring.}

JavaScript (ES7), 55 53 byte

Berdasarkan rumus langsung yang digunakan oleh xnor .

Mengambil input sebagai array.

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

Cobalah online!

Bagaimana?

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

Dan kembali:

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 byte

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

Cobalah online!

Formula langsung. Trik utama untuk mengekspresikan bagian nyata dari output r/sqrt(r*2)untuk memparalelkan ekspresi bagian imajiner, yang menghemat beberapa byte lebih dari:

54 byte

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

Cobalah online!

Arang , 32 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Port of @ xnor's Python answer. Penjelasan:

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

$| 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$

Ｉθ

Keluarkan nilai ke string dan cetak secara implisit.

Java 8, 84 byte

(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 jawaban @xnor dari Python 2 .

Cobalah online.

Penjelasan:

(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 byte

nOtsн+·t©/¦®;š

Port jawaban @xnor dari Python 2 .

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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)

Bahasa Wolfram (Mathematica) , 28 byte

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

Port of @ xnor's Python 2 menjawab .

Cobalah online!

C # .NET, 88 byte

(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 of Java 8 saya menjawab , tetapi mengembalikan Tuple alih-alih sebuah String. Saya pikir itu akan lebih pendek, tapi sayangnya Math.Sqrtmemerlukan System-import di C # .NET, berakhir pada 4 byte lebih lama, bukan 10 byte lebih pendek ..>.>

Deklarasi lambda terlihat sangat lucu:

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

Cobalah online.

Perl 6 , 49 byte

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

Cobalah online!

Fungsi kari mengambil input sebagai f(b,c,d)(a). Mengembalikan angka empat sebagai a,(b,c,d).

Penjelasan

{;                                             }  # 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