Ultraradical là gì

Các ultraradical , hoặc Mang triệt để, trong một số thực được định nghĩa là gốc chỉ thực sự của phương trình quintic .$a$$x^5+x+a=0$

Ở đây chúng tôi sử dụng để biểu thị chức năng ultraradical. Ví dụ: , kể từ .$UR(\cdot)$$UR(-100010)=10$$10^5+10-100010=0$

Thử thách

Viết một chương trình đầy đủ hoặc một hàm, lấy một số thực làm đầu vào, và trả về hoặc xuất ra cực trị của nó.

Yêu cầu

Không có sơ hở tiêu chuẩn được cho phép. Các kết quả cho các trường hợp thử nghiệm dưới đây phải chính xác đến ít nhất 6 chữ số có nghĩa, nhưng nói chung chương trình nên tính các giá trị tương ứng cho bất kỳ đầu vào số thực hợp lệ nào.

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

9 vị trí thập phân được làm tròn về 0 được đưa ra để tham khảo. Giải thích được thêm vào cho một số trường hợp thử nghiệm.

 a                         | UR(a)
---------------------------+---------------------
             0             |   0.000 000 000        # 0
             1             |  -0.754 877 (666)      # UR(a) < 0 when a > 0
            -1             |   0.754 877 (666)      # UR(a) > 0 when a < 0
             1.414 213 562 |  -0.881 616 (566)      # UR(sqrt(2))
            -2.718 281 828 |   1.100 93(2 665)      # UR(-e)
             3.141 592 653 |  -1.147 96(5 385)      # UR(pi)
            -9.515 716 566 |   1.515 71(6 566)      # 5th root of 8, fractional parts should match
            10             |  -1.533 01(2 798)
          -100             |   2.499 20(3 570)
         1 000             |  -3.977 89(9 393)
      -100 010             |  10.000 0(00 000)      # a = (-10)^5 + (-10)
 1 073 741 888             | -64.000 0(00 000)      # a = 64^5 + 64

Tiêu chí chiến thắng

Bài nộp hợp lệ ngắn nhất trong mọi ngôn ngữ sẽ thắng.

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

Root[xx^5+x+#,1]&

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

Vẫn là một tích hợp, nhưng ít nhất là không UltraRadical.

(ký tự được hiển thị như |->trong Mathicala, tương tự như =>trong JS)

Python 3.8 (tiền phát hành) , 60 byte

f=lambda n,x=0:x!=(a:=x-(x**5+x+n)/(5*x**4+1))and f(n,a)or a

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

Phương pháp lặp Newton. $x' = x - \frac {f(x)} {f'(x)} = x - \frac {x^5+x+n} {5x^4+1}$

Trong khi sử dụng $\frac {4x^5-n} {5x^4+1}$ tương đương về mặt toán học, nó làm cho vòng lặp chương trình mãi mãi.

Cách tiếp cận khác:

Python 3.8 (tiền phát hành) , 102 byte

lambda x:a(x,-x*x-1,x*x+1)
a=lambda x,l,r:r<l+1e-9and l or(m:=(l+r)/2)**5+m+x>0and a(x,l,m)or a(x,m,r)

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

Tìm kiếm nhị phân, cho rằng các chức năng x^5+x+ađang tăng lên. Định bờ cõi đến -abs(x)và abs(x)là đủ nhưng -x*x-1và x*x+1ngắn hơn.

Giới hạn đệ quy của BTW Python quá thấp nên cần có 1e-9 và :=được gọi là toán tử hải mã.

JavaScript (ES7), 44 byte

Một phiên bản an toàn hơn bằng cách sử dụng cùng một công thức như dưới đây nhưng với số lần lặp cố định.

n=>(i=1e3,g=x=>i--?g(.8*x-n/(5*x**4+5)):x)``

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

JavaScript (ES7),  43  42 byte

Phương pháp của Newton, sử dụng $5x^4+5$ như một xấp xỉ của $f'(x)=5x^4+1$ .

n=>(g=x=>x-(x-=(x+n/(x**4+1))/5)?g(x):x)``

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

Làm sao?

Chúng tôi bắt đầu với $x_0=0$ và tính toán đệ quy:

cho đến khi $x_k-x_{k+1}$ không đáng kể.

Thạch , 8 byte

;17B¤ÆrḢ

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

Làm thế nào nó hoạt động:

• Xây dựng danh sách [a, 1, 0, 0, 0, 1]bằng cách thêm vào abiểu diễn nhị phân của 17. Tại sao danh sách này? Bởi vì nó tương ứng với các hệ số mà chúng tôi đang tìm kiếm:

  [a, 1, 0, 0, 0, 1] -> P(x) := a + 1*x^1 + 0*x^2 + 0*x^3 + 0*x^4 + 1*x^5 = a + x + x^5
  

• Sau đó, Ærlà một tích hợp để giải phương trình đa thức P(x) = 0, đưa ra một danh sách các hệ số (những gì chúng ta đã xây dựng trước đó).

• Chúng tôi chỉ quan tâm đến giải pháp thực sự, vì vậy chúng tôi lấy mục đầu tiên trong danh sách các giải pháp với Ḣ.

APL (Dyalog Unicode) , 11 10 byte ^SBCS

-1 nhờ dzaima

Chức năng tiền tố ẩn danh.

(--*∘5)⍣¯1

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

(... )⍣¯1 áp dụng thời gian một ngầm chức năng phủ định sau:

 - lập luận phủ định

 - dấu trừ

 *∘5 lập luận nâng lên sức mạnh của 5

Về bản chất, đây hỏi: Những $x$ Tôi cần thức ăn để $f(x)=-x-x^5$$y$

R , 43 byte

function(a)nlm(function(x)abs(x^5+x+a),a)$e

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

nlmlà một chức năng tối ưu hóa, do đó, tìm kiếm tối thiểu của hàm $x\mapsto |x^5+x+a|$nlma

R , 56 byte

function(x)(y=polyroot(c(x,1,0,0,0,1)))[abs(Im(y))<1e-9]

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

polyroot$a$polyroot

J , 14 byte

{:@;@p.@,#:@17

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

J được tích hợp sẵn để giải đa thức ... p.

4 trường hợp thử nghiệm cuối cùng đã hết thời gian trên TIO, nhưng trên lý thuyết vẫn đúng.

làm sao

Các hệ số đa thức cho nội dung của J được lấy dưới dạng danh sách số, với hệ số x^0đầu tiên. Điều này có nghĩa là danh sách này là:

a 1 0 0 0 1

1 0 0 0 1là 17 ở dạng nhị phân, vì vậy chúng tôi biểu thị nó dưới dạng #:@17, sau đó nối thêm đầu vào ,, sau đó áp dụng p., sau đó bỏ hộp kết quả bằng raze ;, sau đó lấy phần tử cuối cùng{:

Ruby , 53 41 byte

->a{x=a/=5;99.times{x-=a/(x**4+1)+x/5};x}

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

Sử dụng Newton-Raphson với số lần lặp cố định và thủ thuật xấp xỉ tương tự như Arnauld

Pari / GP , 34 32 26 24 byte

a->-solve(X=0,a,a-X-X^5)

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

05AB1E , 12 byte

ΔyIy4m>/+5/-

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

Phương pháp của Newton.

k4, 33 31 byte

{{y-(x+y+*/5#y)%5+5*/4#y}[x]/x}

newton-raphson tính toán lặp đi lặp lại cho đến khi một số được hội tụ

chỉnh sửa: -2 nhờ ngn!

Rất tiếc, tất cả đã sai ...

K (oK), 10 byte

{-x+*/5#x}

Pari / GP , 24 byte

a->polrootsreal(x^5+x+a)

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

C, 118b / 96b

#include<math.h>
double ur(double a){double x=a,t=1;while(fabs(t)>1e-6){t=x*x*x*x;t=(x*t+x+a)/(5*t+1);x-=t;}return x;}

118 byte với tên hàm gốc và với một số độ chính xác bổ sung (gấp đôi). Với hack bit có thể tốt hơn, nhưng không thể truy cập.

96 byte với các lần lặp cố định.

double ur(double a){double x=a,t;for(int k=0;k<99;k++){t=x*x*x*x;x=(4*x*t-a)/(5*t+1);}return x;}

Trên thực tế, chức năng của chúng tôi rất tốt, chúng tôi có thể sử dụng các điều chỉnh tốt hơn của phương pháp Newton. Triển khai thực tế và nhanh hơn nhiều (150 byte) sẽ là

#include<math.h>
double ur(double a){double x=a/5,f=1,t;while(fabs(f)>1e-6){t=x*x*x*x;f=(t*(5*t*x+5*a+6*x)+a+x)/(15*t*t-10*a*x*x*x+1);x-=f;}return x;}

Tôi đã kiểm tra nó hoạt động, nhưng tôi quá lười để tìm ra nó sẽ nhanh hơn bao nhiêu. Nên có ít nhất một đơn hàng nhanh hơn như Newton.

Sạch , 61 60 byte

import StdEnv
$a=iter 99(\x=(3.0*x^5.0-a)/inc(4.0*x^4.0))0.0

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

Phương pháp của Newton, lần đầu tiên được thực hiện trong câu trả lời của người dùng202729 .

Sạch sẽ , 124 byte

import StdEnv
$a= ?a(~a)with@x=abs(x^5.0+x+a);?u v|u-d==u=u|v+d==v=v= ?(u+if(@u< @v)0.0d)(v-if(@u> @v)0.0d)where d=(v-u)/3E1

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

Tìm kiếm "nhị phân", thu hẹp vùng tìm kiếm ở mức trên hoặc dưới 99,6% của phạm vi giữa giới hạn cao và thấp ở mỗi lần lặp thay vì 50%.

Python 3 + sympy, 72 byte

lambda y:float(sympy.poly("x**5+x+"+str(y)).all_roots()[0])
import sympy

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

Octave , 25 byte

@(a)fzero(@(x)x^5+x+a,-a)

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

Maplesoft Maple , 23 byte

f:=a->fsolve(x^5+x+a=0)

Thật không may, không có trình biên dịch / máy tính Maple trực tuyến ngoài AFAIK. Nhưng mã này khá đơn giản.