Forward difference: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (7 intermediate revisions by 6 users not shown) | |||
Line 50:
{{trans|Python}}
<
F difn(s, n) -> [Int]
R I n != 0 {difn(dif(s), n - 1)} E s
Line 57:
L(i) 10
print(difn(s, i))</
{{out}}
Line 74:
=={{header|Ada}}==
<
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Ada.containers.Vectors;
Line 123:
Print(Diff(A, 10));
print(Diff(A, 0));
end Forward_Difference;</
{{out}}
<pre>
Line 138:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}
<
MODE LISTREAL = [1:0]REAL;
Line 158:
printf((list fmt,s,$";"l$))
OD
)</
{{out}}
<pre>
Line 174:
=={{header|ALGOL W}}==
<
% calculate forward differences %
Line 204:
for i := 1 until length do v( i ) := diff( i )
end for_order
end.</
{{out}}
<pre>
Line 221:
{{works with|Dyalog APL}}{{trans|J}}
<
fd ← {⍺=0:⍵⋄(⍺-1)∇(1↓⍵)-(¯1↓⍵)}
Line 229:
2 fd list
54 ¯40 22 17 13 ¯73 100 ¯32</
=={{header|AppleScript}}==
{{Trans|JavaScript}}
<
on forwardDifference(xs)
zipWith(my subtract, xs, rest of xs)
Line 453:
return lst
end tell
end zipWith</
{{Out}}
<pre>0 -> [90, 47, 58, 29, 22, 32, 55, 5, 55, 73]
Line 468:
=={{header|Arturo}}==
<
; vsub [1 2 3] [1 2 3] ; [0 0 0]
vsub: function [u v][
map
]
Line 477:
order: attr "order"
if order = null -> order: 1
loop 1..order 'n -> block: vsub block drop block
return block
]
print differences .order: 4 [90.5 47 58 29 22 32 55 5 55 73.5]
print differences [1 2 3 4 5 6 7]</
{{out}}
Line 491:
=={{header|AutoHotkey}}==
contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276470.html#276470 forum]
<
MsgBox % diff("2,3,4,3",2)
MsgBox % diff("2,3,4,3",3)
Line 507:
}
Return list
}</
=={{header|AWK}}==
<
BEGIN {
if (p<1) {p = 1};
Line 530:
{
print diff($0, p);
}</
Using Pascal's triangle:
<
BEGIN {
if (p<1) {p = 1};
Line 560:
{
print diff($0, p);
}</
{{out}}
Line 584:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
A() = 90.0, 47.0, 58.0, 29.0, 22.0, 32.0, 55.0, 5.0, 55.0, 73.0
PRINT "Original array: " FNshowarray(A())
Line 613:
a$ += STR$(a(i%)) + ", "
NEXT
= LEFT$(LEFT$(a$))</
{{out}}
<pre>
Line 627:
Left argument is the order, right argument is the array.
<
•Show 1 FDiff 90‿47‿58‿29‿22‿32‿55‿5‿55‿73
•Show 2 FDiff 90‿47‿58‿29‿22‿32‿55‿5‿55‿73</
=={{header|C}}==
<
#include <string.h>
#include <stdio.h>
Line 671:
return 0;
}</
Use method with Pascal triangle, binomial coefficients are pre-computed
<
int* binomCoeff(int n) {
Line 708:
printf("\n");
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
<
using System.Collections.Generic;
using System.Linq;
Line 738:
} while ((sequence = ForwardDifference(sequence)).Any());
}
}</
{{out}}
<pre>90, 47, 58, 29, 22, 32, 55, 5, 55, 73
Line 757:
which is then called several times for calculating n-th order forward difference.
No error checking is implemented.
<
#include <iterator>
#include <algorithm>
Line 867:
return 0;
}</
{{out}}
Line 881:
===Using Standard Template Library===
<
#include <iostream>
#include <numeric>
Line 898:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 913:
Usually one will not want the intermediate results,
in which case the following is sufficient:
<
#include <iostream>
#include <numeric>
Line 927:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 934:
===Using Pascal's Triangle===
<
#include <iostream>
#include <algorithm>
Line 949:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 956:
=={{header|Clojure}}==
<
(nth (iterate #(map - (next %) %) nums) order))</
=={{header|CoffeeScript}}==
<
forward_difference = (arr, n) ->
# Find the n-th order forward difference for arr using
Line 972:
for n in [0..arr.length]
console.log n, forward_difference arr, n
</syntaxhighlight>
{{out}}
<pre>> coffee forward_difference.coffee
Line 987:
=={{header|Common Lisp}}==
<
(mapcar #'- (rest list) list))
Line 993:
(setf list (copy-list list))
(loop repeat n do (map-into list #'- (rest list) list))
(subseq list 0 (- (length list) n)))</
=={{header|D}}==
===Basic Version===
<
in {
assert(level >= 0 && level < data.length);
Line 1,015:
foreach (immutable level; 0 .. data.length)
forwardDifference(data, level).writeln;
}</
{{out}}
<pre>[90.5, 47, 58, 29, 22, 32, 55, 5, 55, 73.5]
Line 1,030:
===Alternative Version===
Same output.
<
auto forwardDifference(Range)(Range d, in int level) pure {
Line 1,042:
foreach (immutable level; 0 .. data.length)
forwardDifference(data, level).writeln;
}</
===Using Vector Operations===
forwardDifference mutates the array in-place (same output):
<
T[] forwardDifference(T)(T[] s, in int n) pure nothrow @nogc {
Line 1,057:
foreach (immutable level; 0 .. A.length)
forwardDifference(A.dup, level).writeln;
}</
===Short Functional Version===
Same output:
<
import std.stdio, std.range;
Line 1,070:
a[n - 1][0 .. $ - 1])[0 .. $] }(D)
.take(D.length));
}</
=={{header|Dart}}==
<
for (int i = _list.length - 1; i > 0; i--) {
_list[i] = _list[i] - _list[i - 1];
Line 1,089:
print(_list);
}
}</
{{out}}
Line 1,110:
=={{header|E}}==
<
/** Single step. */
def forwardDifference(seq :List) {
Line 1,141:
> require(r1 == nthForwardDifference2(sampleData, n))
> println(r1)
> }</
=={{header|EchoLisp}}==
Using the built-in function '''iterate''' which, given a function f and n, returns the function f°f°f....°f .
<
(define (Δ-1 list)
(for/list ([x (cdr list)] [y list]) (- x y)))
Line 1,153:
((Δ-n 9) '(90 47 58 29 22 32 55 5 55 73))
→ (-2921)
</syntaxhighlight>
=={{header|Elixir}}==
<
def forward(list,i\\1) do
forward(list,[],i)
Line 1,170:
Enum.each(1..9, fn i ->
Diff.forward([90, 47, 58, 29, 22, 32, 55, 5, 55, 73],i)
end)</
{{out}}
Line 1,186:
=={{header|Erlang}}==
<
-export([difference/1, difference/2]).
Line 1,203:
io:format("Initial: ~p~n",[?TEST_DATA]),
[io:format("~3b: ~p~n",[N,difference(?TEST_DATA,N)]) || N <- lists:seq(0,length(?TEST_DATA))],
ok.</
{{out}}
<pre>80> forward_difference:task().
Line 1,223:
=={{header|F_Sharp|F#}}==
Straightforward recursive solution
<
match n with
| _ when input = [] || n < 0 -> [] // If there's no more input, just return an empty list
Line 1,231:
|> Seq.zip input // tupled with itself
|> Seq.map (fun (a, b) -> b-a) // Subtract the i'th element from the (i+1)'th
|> Seq.toList) (n-1) // Make into a list and do an n-1 difference on it</
=={{header|Factor}}==
<
IN: rosetacode
Line 1,243:
dup 0 <=
[ drop ] [ [ 1-order ] times ] if ;
</syntaxhighlight>
( scratchpad ) { 90.5 47 58 29 22 32 55 5 55 73.5 } 4 n-order .
{ 156.5 -67 1 -82 259 -304.5 }
=={{header|Forth}}==
<
dup 0
?do
Line 1,262:
: test a 10 9 forward-difference bounds ?do i ? loop ;
test</
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
IMPLICIT NONE
Line 1,285:
WRITE (*,*) b(1:arraysize-n)
END SUBROUTINE Fdiff
END MODULE DIFFERENCE</
<
USE DIFFERENCE
Line 1,299:
END DO
END PROGRAM TEST</
{{out}}
<pre>
Line 1,314:
=={{Header|FreeBASIC}}==
<
dim as uinteger ptr b = allocate( sizeof(uinteger) * (ubound(a)-1) )
for i as uinteger = 0 to ubound(a)-1
Line 1,331:
print *(b+i)
next i
</syntaxhighlight>
=={{header|Go}}==
<
import "fmt"
Line 1,351:
}
return a[:len(a)-ord]
}</
{{out}}
<pre>
Line 1,360:
=={{header|Haskell}}==
<
forwardDifference = tail >>= zipWith (-)
Line 1,369:
main =
mapM_ print $
take 10 (iterate forwardDifference [90, 47, 58, 29, 22, 32, 55, 5, 55, 73])</
{{Out}}
<pre>[90,47,58,29,22,32,55,5,55,73]
Line 1,383:
=={{header|HicEst}}==
<
list = ( 90, 47, 58, 29, 22, 32, 55, 5, 55, 73 )
Line 1,394:
ENDDO
END</
{{out}}
<pre>0 90 47 58 29 22 32 55 5 55 73
Line 1,408:
=={{header|Icon}} and {{header|Unicon}}==
<
every order := 1 to (*A-1) do showList(order, fdiff(A, order))
end
Line 1,424:
every writes(!L," ")
write()
end</
{{out|A sample run}}
Line 1,444:
Standard IDL library function <tt>TS_diff(X,k,[/double])</tt>:
<
15.1473 58.0953 82.7465 16.8637 97.7182 59.7856 17.7699 74.9154
print,ts_diff(x,1)
Line 1,451:
-18.2967 -90.5341 146.737 -118.787 -4.08316 99.1613 0.000000 0.000000
print,ts_diff(x,3)
72.2374 -237.271 265.524 -114.704 -103.244 0.000000 0.000000 0.000000</
=={{header|J}}==
Of the many ways to code this in J, a particularly concise solution is:
<
Alternatively, to reduce the number of J primitives, use:
<
(which is also elegant, because the open-ended power conjunction reads like "to the power of anything").
For example:
<
1 fd list
Line 1,469:
2 fd list
54 _40 22 17 13 _73 100 _32</
J is array oriented, so you can even ask for more than one forward difference at a time (i.e. <tt>N</tt> can be a list, instead of a single number):
<
43 _11 29 7 _10 _23 50 _50 _18
54 _40 22 17 13 _73 100 _32 0
Line 1,488:
1017 _1904 0 0 0 0 0 0 0 0
2921 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0</
=={{header|Java}}==
{{works with|Java|1.5+}}
<
public class FD {
public static void main(String args[]) {
Line 1,518:
return a;
}
}</
{{out}}
Line 1,533:
===ES6===
<
'use strict';
Line 1,689:
// MAIN ---
return main();
})();</
{{Out}}
Line 1,705:
=={{header|jq}}==
{{works with|jq|1.4}}
<
# a (possibly empty) array of numbers,
# emit an array, even if the input list is too short:
Line 1,712:
elif n == 1 then . as $in | [range(1;length) | $in[.] - $in[.-1]]
else ndiff(1) | ndiff(n-1)
end;</
'''Example''':
<
range(0;12) as $i | (s|ndiff($i))</
{{out}}
<
[90,47,58,29,22,32,55,5,55,73]
[-43,11,-29,-7,10,23,-50,50,18]
Line 1,730:
[-2921]
[]
[]</
=={{header|Julia}}==
Line 1,736:
Using the built-in <code>diff</code> function, which returns the 1st forward difference:
<
s = [90, 47, 58, 29, 22, 32, 55, 5, 55, 73]
println.(collect(ndiff(s, i) for i in 0:9))</
{{out}}
Line 1,754:
=={{header|K4}}==
<syntaxhighlight lang
To compute the ''n''th forward difference, call as:
<syntaxhighlight lang
In order to obtain all intermediate results, call as:
<syntaxhighlight lang
{{out|Examples}}
Line 1,771:
=={{header|Kotlin}}==
<
fun forwardDifference(ia: IntArray, order: Int): IntArray {
Line 1,806:
printArray(fd)
}
}</
{{out}}
Line 1,824:
=={{header|Lambdatalk}}==
<
{def fdiff
{lambda {:l}
Line 1,852:
[1017,-1904]
[-2921]
</syntaxhighlight>
=={{header|Lasso}}==
<
define forwardDiff(values, order::integer=1) => {
Line 1,870:
local(data = (:90, 47, 58, 29, 22, 32, 55, 5, 55, 73))
with x in generateSeries(0, #data->size-1)
do stdoutnl(#x + ': ' + forwardDiff(#data, #x))</
{{out}}
<pre>0: array(90, 47, 58, 29, 22, 32, 55, 5, 55, 73)
Line 1,884:
=={{header|Logo}}==
<
if empty? :l [output []]
if empty? bf :l [output []]
Line 1,895:
show nth.fwd.diff 9 [90 47 58 29 22 32 55 5 55 73]
[-2921]</
=={{header|Lua}}==
<
if(b) then return b-a, dif(b, ...) end
end
function dift(t) return {dif(unpack(t))} end
print(unpack(dift{1,3,6,10,15}))</
=={{header|M2000 Interpreter}}==
Function Diff(a()) get an array by value (a shallow copy)
<syntaxhighlight lang="m2000 interpreter">
Form 80, 40
Module Forward_difference {
Line 1,928:
Forward_difference
</syntaxhighlight>
{{out}}
<pre style="height:30ex;overflow:scroll">
Line 1,945:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Built-in function:
<
Differences[i]</
{{out|gives back}}
<
The n<sup>th</sup> difference can be done as follows:
<
Differences[i,n]</
=={{header|MATLAB}} / {{header|Octave}}==
Line 1,958:
X is the list of numbers,
n is the order of the forward difference.
<
{{out}} 1st order forward difference.
Line 1,968:
=={{header|Maxima}}==
<
=={{header|NetRexx}}==
<
* Forward differences
* 18.08.2012 Walter Pachl derived from Rexx
Line 2,004:
Say n ol
End
End</
Output is the same as for Rexx
=={{header|Nial}}==
Define forward difference for order 1
<
{{out}} forward difference of 4th order
<
4 fold fd b
= 156 -67 1 -82 259 -305</
=={{header|Nim}}==
<
result = newSeq[int](s.len-1)
for i in 0..<s.high:
Line 2,029:
echo difn(s, 0)
echo difn(s, 1)
echo difn(s, 2)</
{{out}}
<pre>@[90, 47, 58, 29, 22, 32, 55, 5, 55, 73]
Line 2,037:
=={{header|Objeck}}==
{{trans|Java}}
<
bundle Default {
class Test {
Line 2,074:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
<
a :: (b :: _ as xs) ->
b - a :: forward_difference xs
Line 2,088:
xs
else
nth_forward_difference (pred n) (forward_difference xs)</
{{out}}
Line 2,098:
=={{header|Oforth}}==
<
: forwardDiffN(n, l) l #[ forwardDiff dup println ] times(n) ;</
{{out}}
<pre>
Line 2,116:
=={{header|PARI/GP}}==
<
=={{header|Pascal}}==
<
procedure fowardDifference(list: array of integer);
Line 2,144:
begin
fowardDifference(a);
end.</
{{out}}
<pre>:> ./ForwardDifference
Line 2,159:
=={{header|Perl}}==
<
my @s = @_;
map { $s[$_+1] - $s[$_] } 0 .. $#s-1
Line 2,165:
@a = qw<90 47 58 29 22 32 55 5 55 73>;
while (@a) { printf('%6d', $_) for @a = dif @a; print "\n" }</
{{out}}
<pre> -43 11 -29 -7 10 23 -50 50 18
Line 2,178:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">fwd_diff_n</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">order</span><span style="color: #0000FF;">)</span>
Line 2,196:
<span style="color: #0000FF;">?</span><span style="color: #000000;">fwd_diff_n</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 2,212:
=={{header|PHP}}==
<
function forwardDiff($anArray, $times = 1) {
Line 2,254:
}
}</
=={{header|Picat}}==
<
L = [90, 47, 58, 29, 22, 32, 55, 5, 55, 73],
foreach(I in 1..L.length-1)
Line 2,287:
Diffs1 := Diffs1 ++ [Diff]
end,
Diffs = Diffs1.</
{{out}}
<pre>[d = 1,[-43,11,-29,-7,10,23,-50,50,18]]
[d = 2,[54,-40,22,17,13,-73,100,-32]]
Line 2,303:
=={{header|PicoLisp}}==
<
(mapcar - (cdr Lst) Lst) )
(for (L (90 47 58 29 22 32 55 5 55 73) L (fdiff L))
(println L) )</
{{out}}
<pre>(90 47 58 29 22 32 55 5 55 73)
Line 2,321:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
/* Forward differences. */ /* 23 April 2010 */
differences: procedure options (main);
Line 2,343:
end differences;
</syntaxhighlight>
=={{header|Plain English}}==
<
Allocate memory for a fraction thing.
Put the fraction into the fraction thing's fraction.
Line 2,400:
If the fraction thing's next is not nil, write ", " on the console without advancing.
Put the fraction thing's next into the fraction thing.
Repeat.</
{{out}}
<pre>
Line 2,410:
=={{header|Pop11}}==
<
lvars res = [], prev, el;
if l = [] then
Line 2,429:
endfor;
res;
enddefine;</
=={{header|PowerShell}}==
<math>\Delta^n [f](x)= \sum_{k=0}^n \left ({\prod_{i=1}^k \frac{n-k+i}{i}}\right ) (-1)^{n-k} f(x+k)</math>
<
{
$flen = $f.length
Line 2,454:
}
Forward-Difference 2 1,2,4,5</
=={{header|PureBasic}}==
<
If ListSize(a()) <= 1
ClearList(a()): ProcedureReturn
Line 2,511:
EndIf
</syntaxhighlight>
{{out}}
<pre>1 [43,-11,29,7,-10,-23,50,-50,-18]
Line 2,526:
=={{header|Python}}==
===Python 2===
<
>>> # or, dif = lambda s: [x-y for x,y in zip(s[1:],s)]
>>> difn = lambda s, n: difn(dif(s), n-1) if n else s
Line 2,549:
[-442, 575, -1329],
[1017, -1904],
[-2921]]</
===Python 3===
Defining functions for first order and nth order forward difference:
{{Works with|Python|3.7}}
<
Line 2,646:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>9th order forward difference of:
Line 2,667:
=={{header|Quackery}}==
<
[ [] swap behead
swap witheach
Line 2,679:
dup echo say ": "
f-diff echo cr ]
drop</
{{out}}
Line 2,696:
=={{header|R}}==
<
if ( n == 1 )
a[2:length(a)] - a[1:length(a)-1]
Line 2,716:
print(forwarddif(v, 9))
print(fdiff(v, 9))</
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 2,732:
(nth-forward-difference 9 '(90 47 58 29 22 32 55 5 55 73))
;; -> '(-2921)
</syntaxhighlight>
=={{header|Raku}}==
Line 2,740:
The Z- operator is a zip metaoperator with a minus to subtract the two lists pairwise.
It's almost a shame to define difn, since the series and subscript are hardly longer than the call itself would be, and arguably more self-documenting than the name of the function would be.
<syntaxhighlight lang="raku"
sub difn($array, $n) { ($array, &dif ... *)[$n] }</
=={{header|REXX}}==
Line 2,748:
This version allows a specification of the list of numbers and/or which ''order'' to process.
<
numeric digits 100 /*ensure enough accuracy (decimal digs)*/
parse arg e ',' N /*get a list: ε1 ε2 ε3 ε4 ··· , order */
Line 2,770:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
th: procedure; x=abs(arg(1)); return word('th st nd rd',1+x//10*(x//100%10\==1)*(x//10<4))</
'''output''' when using the default input:
<pre>
Line 2,805:
===with error checking===
<
numeric digits 100 /*ensure enough accuracy (decimal digs)*/
parse arg e ',' N /*get a list: ε1 ε2 ε3 ε4 ··· , order */
Line 2,833:
/*──────────────────────────────────────────────────────────────────────────────────────*/
ser: say; say '***error***'; say arg(1); say; exit 13
th: procedure; x=abs(arg(1)); return word('th st nd rd',1+x//10*(x//100%10\==1)*(x//10<4))</
'''output''' is the same as the REXX entry above.
===with output alignment===
<
numeric digits 100 /*ensure enough accuracy (decimal digs)*/
parse arg e ',' N /*get a list: ε1 ε2 ε3 ε4 ··· , order */
Line 2,869:
/*──────────────────────────────────────────────────────────────────────────────────────*/
ser: say; say '***error***'; say arg(1); say; exit 13
th: procedure; x=abs(arg(1)); return word('th st nd rd',1+x//10*(x//100%10\==1)*(x//10<4))</
'''output''' when using the default input:
<pre>
Line 2,888:
===Version 2===
<
* Forward differences
* 18.08.2012 Walter Pachl derived from PL/I
Line 2,922:
End
End
Return</
{{out}} for Java's input
<pre>
Line 2,941:
=={{header|Ring}}==
<
# Project : Forward difference
Line 2,967:
see svect
see "}" + nl
</syntaxhighlight>
Output:
<pre>
Line 2,980:
{-2921}
</pre>
=={{header|RPL}}==
===Iterative approach===
{| class="wikitable" ≪
! RPL code
! Comment
|-
|
≪
'''IF''' OVER SIZE OVER > '''THEN'''
'''WHILE''' DUP '''REPEAT'''
SWAP { } 2 3 PICK SIZE '''FOR''' j
OVER j GET + '''NEXT'''
LIST→ →ARRY
SWAP OVER SIZE { } + RDM -
SWAP 1 - '''END'''
DROP '''END'''
≫ ‘<span style="color:blue">DIFFN</span>’ STO
|
<span style="color:blue">DIFFN</span> ''( [array] order → [nth_difference] ) ''
if order < array size
while order > 0
initialize loop
to build { array[2]...array[n] }
convert list into array
pop last item of array and substract
order -= 1
clean stack
|}
[90, 47, 58, 29, 22, 32, 55, 5, 55, 73] 1 <span style="color:blue">DIFFN</span>
[90, 47, 58, 29, 22, 32, 55, 5, 55, 73] 3 <span style="color:blue">DIFFN</span>
{{out}}
<pre>
2: [-43, 11, -29, -7, 10, 23, -50, 50, 18]
1: [-94, 62, -5, -4, -86, 173, -132]
</pre>
===Direct approach===
We use here local variables and algebraic notation to increase code readability.
{| class="wikitable" ≪
! RPL code
! Comment
|-
|
≪ → n
≪ '<span style="color:green">F</span>' STO
{ } 1 <span style="color:green">F</span> SIZE 1 - '''FOR''' j
-1 n ^ '<span style="color:green">F</span>' j GET *
1 n '''FOR''' k
'COMB(n,k)*(-1)^(n-k)*<span style="color:green">F</span>(j+k)' EVAL +
'''NEXT'''
+ '''NEXT'''
LIST→ →ARRY '<span style="color:green">F</span>' PURGE
≫ ≫ ‘<span style="color:blue">DIFFN</span>’ STO
|
<span style="color:blue">DIFFN</span> ''( [array] order → [nth_difference] ) ''
store array in global variable F
initialize output array building loop
put 1st term of sum (k=0) in stack // reverse Polish notation
loop
add terms for 0<k≤n // algebraic notation
add sum to list
convert list into array, clean memory
|}
Postfix fans can replace the following line
'COMB(n,k)*(-1)^(n-k)*<span style="color:green">F</span>(j+k)' EVAL + '''NEXT'''
by
n k COMB -1 n k - ^ * '<span style="color:green">F</span>' j k + GET * + '''NEXT'''
On HP-48G and newer models, first difference is directly returned by the <code>ΔLIST</code> instruction, so we can simplify the above code, provided that input is given as a list { } instead of an array [ ]:
≪ 1 SWAP '''START''' ΔLIST '''NEXT''' ≫ ‘<span style="color:blue">DIFFN</span>’ STO
=={{header|Ruby}}==
Line 2,988 ⟶ 3,061:
{{works with|Ruby|1.8.7}}
<
s.each_cons(2).collect { |x, y| y - x }
end
Line 2,994 ⟶ 3,067:
def difn(s, n)
n.times.inject(s) { |s, | dif(s) }
end</
{{out|Example usage}}
<
p difn([1, 23, 45, 678], 2) # => [0, 611]</
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn forward_difference(input_seq: Vec<i32>, order: u32) -> Vec<i32> {
match order {
0 => input_seq,
1 => {
let input_seq_iter = input_seq.into_iter();
let clone_of_input_seq_iter = input_seq_iter.clone();
input_seq_iter.zip(clone_of_input_seq_iter.skip(1)).map(|(current, next)| next - current).collect()
},
_ => forward_difference(forward_difference(input_seq, order - 1), 1),
}
}
fn main() {
let mut sequence = vec![90, 47, 58, 29, 22, 32, 55, 5, 55, 73];
loop {
println!("{:?}", sequence);
sequence = forward_difference(sequence, 1);
if sequence.is_empty() {
break;
}
}
}
</syntaxhighlight>
{{out}}
<pre>
[90, 47, 58, 29, 22, 32, 55, 5, 55, 73]
[-43, 11, -29, -7, 10, 23, -50, 50, 18]
[54, -40, 22, 17, 13, -73, 100, -32]
[-94, 62, -5, -4, -86, 173, -132]
[156, -67, 1, -82, 259, -305]
[-223, 68, -83, 341, -564]
[291, -151, 424, -905]
[-442, 575, -1329]
[1017, -1904]
[-2921]
</pre>
=={{header|Scala}}==
<
def fdiffn(i: Int, xs: List[Int]): List[Int] = if (i == 1) fdiff(xs) else fdiffn(i - 1, fdiff(xs))</
{{out|Example}}
<
(1 to 9)foreach(x=>println(fdiffn(x,l)))</
{{out}}
<pre>
Line 3,022 ⟶ 3,136:
=={{header|Scheme}}==
<
(if (or (null? lst) (null? (cdr lst)))
'()
Line 3,032 ⟶ 3,146:
xs
(nth-forward-diff (- n 1)
(forward-diff xs))))</
{{out}}
Line 3,041 ⟶ 3,155:
=={{header|Seed7}}==
<
const func array integer: forwardDifference (in array integer: data) is func
Line 3,073 ⟶ 3,187:
data := forwardDifference(data);
end for;
end func;</
{{out}}
Line 3,091 ⟶ 3,205:
=={{header|SequenceL}}==
Solution that keeps track of intermediate values:
<syntaxhighlight lang="sequencel">
forwardDifference(x(1), n) := forwardDifferenceHelper(x, n, [x]);
Line 3,100 ⟶ 3,214:
result when n = 0 or size(x) = 1 else
forwardDifferenceHelper(difference, n - 1, result ++ [difference]);
</syntaxhighlight>
If no intermediate values are needed, the following is sufficient:
<syntaxhighlight lang="sequencel">
forwardDifference(x(1),n) :=
x when n = 0 or size(x) = 1 else
forwardDifference(tail(x) - x[1 ... size(x) - 1], n - 1);
</syntaxhighlight>
=={{header|Sidef}}==
<
gather {
for i (0 ..^ arr.end) {
Line 3,123 ⟶ 3,237:
say dif([1, 23, 45, 678]) # => [22, 22, 633]
say difn(2, [1, 23, 45, 678]) # => [0, 611]</
=={{header|Slate}}==
<
[
s allButFirst with: s allButLast collect: #- `er
Line 3,142 ⟶ 3,256:
[
(0 below: n) inject: s into: [| :seq :_ | seq forwardDifference]
].</
{{out|Usage}}
<
data keysDo: [| :index | inform: (data forwardDifference: index) printString].</
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
difference [
^self allButFirst with: self allButLast collect: [ :a :b | a - b ]
Line 3,163 ⟶ 3,277:
s := #(90 47 58 29 22 32 55 5 55 73)
1 to: s size - 1 do: [ :i |
(s nthOrderDifference: i) printNl ]</
=={{header|SQL}}==
Line 3,169 ⟶ 3,283:
{{works with|SQLite|3.13.0}}
<
T0 (N, ITEM, LIST, NEW_LIST) AS
(
Line 3,205 ⟶ 3,319:
WHERE NEW_LIST IS NULL
AND LIST <> ''
ORDER BY N;</
=={{header|Standard ML}}==
<
fun nth_forward_difference n xs =
Line 3,215 ⟶ 3,329:
xs
else
nth_forward_difference (n-1) (forward_difference xs)</
{{out}}
Line 3,226 ⟶ 3,340:
It's possible to implement differences using row indices. For instance, first forward differences of a variable x can be defined by:
<
However, it's much more natural to use [http://www.stata.com/help.cgi?tsvarlist time-series varlists]. In order to use them, it's necessary to first set a ''time'' variable, which may be simply an index variable.
<
clear all
set obs 100
Line 3,239 ⟶ 3,353:
* Differences
display "Difference order?" _request(k)
gen y=D${k}F${k}.x</
=={{header|Swift}}==
<
return zip(arr.dropFirst(), arr).map({ $0.0 - $0.1 })
}
Line 3,262 ⟶ 3,376:
for diff in (0...9).map({ nthForwardsDifference(of: [90, 47, 58, 29, 22, 32, 55, 5, 55, 73], n: $0) }) {
print(diff)
}</
{{out}}
Line 3,278 ⟶ 3,392:
=={{header|Tcl}}==
<
set previous [lindex $list 0]
set new [list]
Line 3,300 ⟶ 3,414:
for {set order 0} {$order <= 10} {incr order} {
puts [format "%d\t%s" $order [fwd_diff $a $order]]
}</
{{out}}
<pre>0 90.5 47 58 29 22 32 55 5 55 73.5
Line 3,317 ⟶ 3,431:
This function doesn't need to be defined because it's in a library already,
but it could be defined like this:
<
#import nat
#import flo
nth_diff "n" = rep"n" minus*typ</
test program:
<
#show+
Line 3,331 ⟶ 3,445:
printf/*=*' %0.0f' <
nth_diff6 test_data,
nth_diff7 test_data></
{{out}}
<pre> 291 -151 424 -905
Line 3,338 ⟶ 3,452:
=={{header|Visual Basic .NET}}==
{{works with|Visual Basic .NET|2008+}}
<
Sub Main()
Line 3,359 ⟶ 3,473:
End Function
End Module</
{{out}}
<pre>
Line 3,375 ⟶ 3,489:
=={{header|Visual FoxPro}}==
<
#DEFINE CTAB CHR(9)
LOCAL lcList As String, i As Integer, n As Integer
Line 3,413 ⟶ 3,527:
? lcTxt
ENDPROC
</syntaxhighlight>
{{out}}
<pre>
Line 3,430 ⟶ 3,544:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
var forwardDiff = Fn.new { |a, order|
Line 3,447 ⟶ 3,561:
}
forwardDiff.call([90, 47, 58, 29, 22, 32, 55, 5, 55, 73], 9)</
{{out}}
Line 3,461 ⟶ 3,575:
8: 1017 -1904
9: -2921
</pre>
=={{header|XPL0}}==
{{trans|ALGOL W}}
<syntaxhighlight lang "XPL0">\Calculate forward differences
\Sets elements of B to the first order forward differences of A.
\A should have bounds 1 :: N, B should have bounds 1 :: N - 1.
procedure FirstOrderFDifference ( A, B, N );
integer A, B, N, I;
for I := 2 to N do B( I - 1 ) := A( I ) - A( I - 1 );
integer V ( 1 + 10 );
integer Diff( 1 + 9 );
integer VPos, Length, List, I, Order;
begin
\construct the initial values array
VPos := 1;
List:= [90, 47, 58, 29, 22, 32, 55, 5, 55, 73];
for I := 0 to 10-1 do begin
V( VPos ) := List( I );
VPos := VPos + 1
end;
\calculate and show the differences
Format(8, 0); \set output format
Length := 10;
for Order := 1 to Length - 1 do begin
FirstOrderFDifference( V, Diff, Length );
Length := Length - 1;
IntOut(0, Order); Text(0, " : ");
for I := 1 to Length do RlOut(0, float(Diff( I ) ));
CrLf(0);
for I := 1 to Length do V( I ) := Diff( I )
end
end</syntaxhighlight>
{{out}}
<pre>
1 : -43 11 -29 -7 10 23 -50 50 18
2 : 54 -40 22 17 13 -73 100 -32
3 : -94 62 -5 -4 -86 173 -132
4 : 156 -67 1 -82 259 -305
5 : -223 68 -83 341 -564
6 : 291 -151 424 -905
7 : -442 575 -1329
8 : 1017 -1904
9 : -2921
</pre>
=={{header|zkl}}==
{{trans|Scheme}}
<
if(lst.len()<2)
return(T);
Line 3,474 ⟶ 3,635:
return(xs);
return(nthForwardDiff(n-1,forwardDiff(xs))) // tail recursion
}</
<
{{out}}
<pre>
Line 3,482 ⟶ 3,643:
=={{header|ZX Spectrum Basic}}==
<
20 LET p=1
30 READ n: DIM b(n)
Line 3,495 ⟶ 3,656:
120 FOR i=1 TO n-p
130 PRINT b(i);" ";
140 NEXT i</
| |||