Lý lịch

Đệ tứ là một hệ thống số mở rộng số phức. Một bộ tứ có dạng sau

trong đó $a,b,c,d$ là các số thực và $i,j,k$ là ba đơn vị bậc bốn cơ bản . Các đơn vị có các thuộc tính sau:

Lưu ý rằng phép nhân bậc bốn không giao hoán .

Bài tập

Cho một tứ phân vị không thực , tính toán ít nhất một trong các căn bậc hai của nó.

Làm sao?

Theo câu trả lời Math.SE này , chúng ta có thể diễn đạt bất kỳ quan điểm không thực nào dưới dạng sau:

trong đó $a,b$ là các số thực và $\vec{u}$ là vectơ đơn vị tưởng tượng có dạng $xi + yj + zk$ với $x^2 + y^2 + z^2 = 1$ . Bất kỳ $\vec{u}$ cũng có thuộc tính $\vec{u}^2 = -1$ , vì vậy nó có thể được xem là đơn vị tưởng tượng.

Sau đó, hình vuông của $q$ trông như thế này:

Ngược lại, cho một quaternion $q' = x + y\vec{u}$ , chúng ta có thể tìm ra căn bậc hai của $q'$ bằng cách giải các phương trình sau

trùng với quá trình tìm căn bậc hai của một số phức.

Lưu ý rằng một số thực âm có vô số căn bậc hai, nhưng một số tứ không thực chỉ có hai căn bậc hai .

Đầu vào và đầu ra

Đầu vào là một tứ phương không thực. Bạn có thể lấy nó làm bốn số thực (dấu phẩy động), theo bất kỳ thứ tự và cấu trúc nào bạn chọn. Không thực có nghĩa là ít nhất một trong số $b,c,d$ là khác không.

Đầu ra là một hoặc hai bậc bốn, khi bình phương, bằng với đầu vào.

Các trường hợp thử nghiệm

   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

Được tạo bằng tập lệnh Python này . Chỉ một trong hai câu trả lời đúng được chỉ định cho từng trường hợp kiểm tra; khác là tất cả bốn giá trị phủ định.

Ghi điểm & tiêu chí chiến thắng

Luật golf tiêu chuẩn được áp dụng. Chương trình hoặc hàm ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng.

APL (NARS) , 2 byte

√

NARS đã tích hợp hỗ trợ cho các bộ tứ. ¯ \ _ (⍨) _ /

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

Hãy thử trực tuyến!

Nhiều hơn hoặc ít hơn một công thức thô. Tôi nghĩ rằng tôi có thể sử dụng sự hiểu biết danh sách để lặp đi lặp lại b,c,d, nhưng điều này dường như dài hơn. Python thực sự bị tổn thương ở đây do thiếu các hoạt động véc tơ, đặc biệt là tỷ lệ và quy mô.

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

Hãy thử trực tuyến!

Việc giải trực tiếp bậc hai cũng ngắn hơn so với sử dụng căn bậc hai số phức của Python để giải quyết nó như trong câu lệnh vấn đề.

Ngôn ngữ Wolfram (Mathicala) , 19 byte

Sqrt
<<Quaternions`

Hãy thử trực tuyến!

Mathematica cũng được tích hợp Quancyion, nhưng dài dòng hơn.

_{Mặc dù các phần dựng sẵn trông rất tuyệt, nhưng các giải pháp nâng cấp cũng không sử dụng các phần dựng sẵn! Tôi không muốn bỏ phiếu cho các câu hỏi đạt HNQ.}

JavaScript (ES7), 55 53 byte

Dựa trên công thức trực tiếp được sử dụng bởi xnor .

Đưa đầu vào như một mảng.

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

Hãy thử trực tuyến!

Làm sao?

Cho một mảng $q=[a,b,c,d]$, điều này tính toán:

Và trả lại:

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

Hãy thử trực tuyến!

Một công thức trực tiếp. Thủ thuật chính để thể hiện phần thực của đầu ra là r/sqrt(r*2)song song với biểu thức phần ảo, giúp tiết kiệm một vài byte:

54 byte

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

Hãy thử trực tuyến!

Than , 32 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Cổng câu trả lời Python của @ xnor. Giải trình:

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

Bình phương tất cả các phần tử của đầu vào và lấy tổng, sau đó lấy căn bậc hai. Điều này tính toán$| x + y\vec{u} | = \sqrt{ x^2 + y^2 } = \sqrt{ (a^2 - b^2)^2 + (2ab)^2 } = a^2 + b^2$. Thêm$x$ cho $2a^2$ mà sau đó được nhân đôi và căn bậc hai để cung cấp $2a$.

≧∕ηθ

Bởi vì $y = 2ab$, tính toán $b$ bằng cách chia cho $2a$.

§≔θ⁰⊘η

Đặt phần tử đầu tiên của mảng (tức là phần thực) thành một nửa $2a$.

Ｉθ

Truyền các giá trị thành chuỗi và in ngầm.

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

Cổng câu trả lời Python 2 của @xnor .

Hãy thử trực tuyến.

Giải trình:

(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©/¦®;š

Cổng câu trả lời Python 2 của @xnor .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

Ngôn ngữ Wolfram (Mathicala) , 28 byte

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

Cổng câu trả lời Python 2 của @ xnor .

Hãy thử trực tuyến!

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)

Cổng câu trả lời Java 8 của tôi , nhưng trả về một Tuple thay vì Chuỗi. Tôi nghĩ rằng nó sẽ ngắn hơn, nhưng thật không may, Math.Sqrtyêu cầu một System-import trong C # .NET, kết thúc dài hơn 4 byte thay vì ngắn hơn 10 byte ..>.>

Tuyên bố lambda trông khá buồn cười, mặc dù:

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

Hãy thử trực tuyến.

Perl 6 , 49 byte

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

Hãy thử trực tuyến!

Hàm curried lấy đầu vào là f(b,c,d)(a). Trả về tứ phương như a,(b,c,d).

Giải trình

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