Cara yang saya sukai untuk memperkirakan turunan adalah perbedaan utama, ini lebih akurat daripada perbedaan maju atau perbedaan mundur, dan saya terlalu malas untuk naik ke tingkat yang lebih tinggi. Tetapi perbedaan pusat membutuhkan titik data di kedua sisi titik yang Anda evaluasi. Biasanya ini berarti Anda akhirnya tidak memiliki turunan di kedua titik akhir. Untuk mengatasinya, saya ingin Anda beralih ke perbedaan maju dan mundur di tepi:

Secara khusus, saya ingin Anda menggunakan perbedaan maju untuk poin pertama, perbedaan mundur untuk poin terakhir, dan perbedaan pusat untuk semua poin di tengah. Juga, Anda dapat mengasumsikan nilai x berjarak secara merata, dan fokus hanya pada y. Gunakan formula ini:

Semoga beruntung, saya tak sabar untuk melihat apakah seseorang datang dengan aturan sederhana yang mereproduksi ketiga turunannya di tempat yang tepat!

INPUT EX:

0.034  9.62    8.885   3.477   2.38

Saya akan menggunakan FD, CD, dan BD untuk menunjukkan algoritma yang digunakan di tempat mana, jadi di atas 5 poin digunakan untuk memperkirakan turunan menggunakan

FD     CD      CD      CD     BD

Dan kemudian nilai yang dihitung adalah:

9.586  4.4255 -3.0715 -3.2525 -1.097 

Anda dapat mengasumsikan bahwa akan selalu ada setidaknya 3 titik input, dan Anda dapat menghitung menggunakan presisi tunggal atau ganda.

Dan seperti biasa, jawaban terpendek menang.

Jelly , 13 10 byte

I.ịṚjI+2\H

Cobalah online!

Bagaimana itu bekerja

I.ịṚjI+2\H  Main link. Argument: A (array)

I           Increments; compute the deltas of consecutive values.
            For [a, b, c, d, e], this yields [b-a, c-b, d-c, e-d].
 .ị         At-index 0.5; get the the last and first element.
            This yields [e-d, b-a].
   Ṛ        Reverse the pair.
            This yields [b-a, e-d].
    jI      Join, separating by the increments.
            This yields [b-a, b-a, c-b, d-c, e-d, e-d].
      +2\   Add the values of all overlapping pairs.
            This yields [2(b-a), c-a, d-b, e-c, 2(e-d)].
         H  Halve all resulting numbers.
            This yields [b-a, (c-a)/2, (d-b)/2, (e-c)/2, e-d]. 

MATL, 21 15 byte

2/d1)6Mh8Mt0)h+

TryItOnline

Membagi dua input vektor, dan mengambil perbedaan berturut-turut, untuk memberi d=[i(2)-i(1) i(3)-i(2) ... i(end)-i(end-1)]/2dan kemudian membuat dua vektor yang dimodifikasi, [d(1) d]dan [d d(end)], dan menambahkannya.

Versi yang lebih lama lebih baik (karena konvolusi), tetapi 21 byte

d1j)6M1)6MTT2/H3$Y+bv

Python dengan NumPy, 29 byte

import numpy;numpy.gradient

Ini merupakan perilaku default gradientfungsi NumPy . Byte dihitung berdasarkan konsensus ini .

05AB1E, 20 19 17 14 byte

¥Ð¦øO;s¤s0èŠ)˜

Dijelaskan

¥Ð              # triplicate deltas of list
                  [9.585999999999999, -0.7349999999999994, -5.4079999999999995, -1.097]
  ¦øO;          # get central difference (fold addition over deltas and divide by 2)
                  [4.4254999999999995, -3.0714999999999995, -3.2524999999999995]
      s¤        # get backwards difference
                  -1.097
        s0è     # get forwards difference
                  9.585999999999999
           Š)˜  # reorder differences, merge to list and flatten
                  [9.585999999999999, 4.4254999999999995, -3.0714999999999995, -3.2524999999999995, -1.097]

Cobalah online

Disimpan 2 byte berkat @Adnan

Julia, 8 byte

gradient

Terinspirasi oleh jawaban Python @ MartinEnder . Cobalah online!

Pyth, 14 byte

.OM>L2._seB-Vt

Cobalah online: Peragaan

Penjelasan:

.OM>L2._seB-VtQQ   implicitly add two Qs (input arrays) at the end
           -VtQQ   get all neighbored differences
        seB        get the last element of ^ and append it to ^
      ._           compute all prefixes
   >L2             reduce all prefixes to the last two elements
.OM                compute the average of each ^

J, 21 byte

[:((,{:)+{.,])2-~/\-:

Mirip dengan pendekatan yang digunakan dalam solusi @ David .

Pemakaian

   f =: [:((,{:)+{.,])2-~/\-:
   f 0.034 9.62 8.885 3.477 2.38
9.586 4.4255 _3.0715 _3.2525 _1.097

Penjelasan

[:((,{:)+{.,])2-~/\-:  Input: list A
                   -:  Halve each value in A
              2   \    Select each overlapping sublist of size 2 in A
               -~/     Reduce it using subtraction to get the difference
[:(          )         Operate on the list of differences, call it D
            ]          Identity function, returns D
         {.            Get the head of D
           ,           Join them to get [head(D), D]
   ( {:)               Get the tail of D
    ,                  Join them to get [D, tail(D)]
        +              Add them together elementwise to get the derivatives and return

Pyth - 29 byte

Pendekatan sederhana yang bodoh.

s[_-F<Q2mc-@Qhd@Qtd2tUtQ_-F>2

Cobalah online di sini .

JavaScript (ES6), 62 byte

a=>a.map((_,i)=>i&&i--<a.length-2?(a[i+2]-a[i])/2:a[i+1]-a[i])

Pyth, 27 24 23 21 byte

.bcF_-VNYK ++] hJ, VUQQJ] eJttK 
.bcF-VYN +] hJ, VQUQJ + tJ] eJ 
++ hJ-V + tQeQ + hQQcR2PtJeJ 
* V ++ 1 *] 5ttlQ1-V + tQeQ + h + h
* V ++ 1m.5ttQ1-V + tQeQ + h

Cobalah online!