Forward difference: Difference between revisions

{{trans|Python}}

F difn(s, n) -> [Int]

R I n != 0 {difn(dif(s), n - 1)} E s

L(i) 10

{{out}}

=={{header|Ada}}==

with Ada.Float_Text_Io; use Ada.Float_Text_Io;

with Ada.containers.Vectors;

Print(Diff(A, 10));

print(Diff(A, 0));

{{out}}

<pre>

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

printf((list fmt,s,$";"l$))

OD

{{out}}

<pre>

=={{header|ALGOL W}}==

% calculate forward differences %

for i := 1 until length do v( i ) := diff( i )

end for_order

{{out}}

<pre>

{{works with|Dyalog APL}}{{trans|J}}

fd ← {⍺=0:⍵⋄(⍺-1)∇(1↓⍵)-(¯1↓⍵)}

2 fd list

=={{header|AppleScript}}==

{{Trans|JavaScript}}

on forwardDifference(xs)

zipWith(my subtract, xs, rest of xs)

return lst

end tell

{{Out}}

<pre>0 -> [90, 47, 58, 29, 22, 32, 55, 5, 55, 73]

=={{header|Arturo}}==

; vsub [1 2 3] [1 2 3] ; [0 0 0]

vsub: function [u v][

print differences .order: 4 [90.5 47 58 29 22 32 55 5 55 73.5]

{{out}}

=={{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)

}

Return list

=={{header|AWK}}==

BEGIN {

if (p<1) {p = 1};

{

print diff($0, p);

Using Pascal's triangle:

BEGIN {

if (p<1) {p = 1};

{

print diff($0, p);

{{out}}

=={{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())

a$ += STR$(a(i%)) + ", "

NEXT

{{out}}

<pre>

Left argument is the order, right argument is the array.

•Show 1 FDiff 90‿47‿58‿29‿22‿32‿55‿5‿55‿73

=={{header|C}}==

#include <string.h>

#include <stdio.h>

return 0;

Use method with Pascal triangle, binomial coefficients are pre-computed

int* binomCoeff(int n) {

printf("\n");

}

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Linq;

} while ((sequence = ForwardDifference(sequence)).Any());

}

{{out}}

<pre>90, 47, 58, 29, 22, 32, 55, 5, 55, 73

which is then called several times for calculating n-th order forward difference.

No error checking is implemented.

#include <iterator>

#include <algorithm>

return 0;

{{out}}

===Using Standard Template Library===

#include <iostream>

#include <numeric>

return 0;

}

{{out}}

<pre>

Usually one will not want the intermediate results,

in which case the following is sufficient:

#include <iostream>

#include <numeric>

return 0;

}

{{out}}

<pre>

===Using Pascal's Triangle===

#include <iostream>

#include <algorithm>

return 0;

}

{{out}}

<pre>

=={{header|Clojure}}==

=={{header|CoffeeScript}}==

forward_difference = (arr, n) ->

# Find the n-th order forward difference for arr using

for n in [0..arr.length]

console.log n, forward_difference arr, n

{{out}}

<pre>> coffee forward_difference.coffee

=={{header|Common Lisp}}==

(mapcar #'- (rest list) list))

(setf list (copy-list list))

(loop repeat n do (map-into list #'- (rest list) list))

=={{header|D}}==

===Basic Version===

in {

assert(level >= 0 && level < data.length);

foreach (immutable level; 0 .. data.length)

forwardDifference(data, level).writeln;

{{out}}

<pre>[90.5, 47, 58, 29, 22, 32, 55, 5, 55, 73.5]

===Alternative Version===

Same output.

auto forwardDifference(Range)(Range d, in int level) pure {

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 {

foreach (immutable level; 0 .. A.length)

forwardDifference(A.dup, level).writeln;

===Short Functional Version===

Same output:

import std.stdio, std.range;

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

print(_list);

}

{{out}}

=={{header|E}}==

/** Single step. */

def forwardDifference(seq :List) {

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

((Δ-n 9) '(90 47 58 29 22 32 55 5 55 73))

→ (-2921)

=={{header|Elixir}}==

def forward(list,i\\1) do

forward(list,[],i)

Enum.each(1..9, fn i ->

Diff.forward([90, 47, 58, 29, 22, 32, 55, 5, 55, 73],i)

{{out}}

=={{header|Erlang}}==

-export([difference/1, difference/2]).

io:format("Initial: ~p~n",[?TEST_DATA]),

[io:format("~3b: ~p~n",[N,difference(?TEST_DATA,N)]) || N <- lists:seq(0,length(?TEST_DATA))],

{{out}}

<pre>80> forward_difference:task().

=={{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

|> Seq.zip input // tupled with itself

|> Seq.map (fun (a, b) -> b-a) // Subtract the i'th element from the (i+1)'th

=={{header|Factor}}==

IN: rosetacode

dup 0 <=

[ drop ] [ [ 1-order ] times ] if ;

( 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

: test a 10 9 forward-difference bounds ?do i ? loop ;

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

IMPLICIT NONE

WRITE (*,*) b(1:arraysize-n)

END SUBROUTINE Fdiff

USE DIFFERENCE

END DO

{{out}}

<pre>

=={{Header|FreeBASIC}}==

dim as uinteger ptr b = allocate( sizeof(uinteger) * (ubound(a)-1) )

for i as uinteger = 0 to ubound(a)-1

print *(b+i)

next i

=={{header|Go}}==

import "fmt"

}

return a[:len(a)-ord]

{{out}}

<pre>

=={{header|Haskell}}==

forwardDifference = tail >>= zipWith (-)

main =

mapM_ print $

{{Out}}

<pre>[90,47,58,29,22,32,55,5,55,73]

=={{header|HicEst}}==

list = ( 90, 47, 58, 29, 22, 32, 55, 5, 55, 73 )

ENDDO

{{out}}

<pre>0 90 47 58 29 22 32 55 5 55 73

=={{header|Icon}} and {{header|Unicon}}==

every order := 1 to (*A-1) do showList(order, fdiff(A, order))

end

every writes(!L," ")

write()

{{out|A sample run}}

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)

-18.2967 -90.5341 146.737 -118.787 -4.08316 99.1613 0.000000 0.000000

print,ts_diff(x,3)

=={{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

2 fd list

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

1017 _1904 0 0 0 0 0 0 0 0

2921 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[]) {

return a;

}

{{out}}

===ES6===

'use strict';

// MAIN ---

return main();

{{Out}}

=={{header|jq}}==

{{works with|jq|1.4}}

# a (possibly empty) array of numbers,

# emit an array, even if the input list is too short:

elif n == 1 then . as $in | [range(1;length) | $in[.] - $in[.-1]]

else ndiff(1) | ndiff(n-1)

'''Example''':

{{out}}

[90,47,58,29,22,32,55,5,55,73]

[-43,11,-29,-7,10,23,-50,50,18]

[-2921]

[]

=={{header|Julia}}==

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]

{{out}}

=={{header|K4}}==

To compute the ''n''th forward difference, call as:

In order to obtain all intermediate results, call as:

{{out|Examples}}

=={{header|Kotlin}}==

fun forwardDifference(ia: IntArray, order: Int): IntArray {

printArray(fd)

}

{{out}}

=={{header|Lambdatalk}}==

{def fdiff

{lambda {:l}

[1017,-1904]

[-2921]

=={{header|Lasso}}==

define forwardDiff(values, order::integer=1) => {

local(data = (:90, 47, 58, 29, 22, 32, 55, 5, 55, 73))

with x in generateSeries(0, #data->size-1)

{{out}}

<pre>0: array(90, 47, 58, 29, 22, 32, 55, 5, 55, 73)

=={{header|Logo}}==

if empty? :l [output []]

if empty? bf :l [output []]

show nth.fwd.diff 9 [90 47 58 29 22 32 55 5 55 73]

=={{header|Lua}}==

if(b) then return b-a, dif(b, ...) end

end

function dift(t) return {dif(unpack(t))} end

=={{header|M2000 Interpreter}}==

Function Diff(a()) get an array by value (a shallow copy)

Form 80, 40

Module Forward_difference {

Forward_difference

{{out}}

<pre style="height:30ex;overflow:scroll">

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Built-in function:

{{out|gives back}}

The n^th difference can be done as follows:

=={{header|MATLAB}} / {{header|Octave}}==

X is the list of numbers,

n is the order of the forward difference.

{{out}} 1st order forward difference.

=={{header|Maxima}}==

=={{header|NetRexx}}==

* Forward differences

* 18.08.2012 Walter Pachl derived from Rexx

Say n ol

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

=={{header|Nim}}==

result = newSeq[int](s.len-1)

for i in 0..<s.high:

echo difn(s, 0)

echo difn(s, 1)

{{out}}

<pre>@[90, 47, 58, 29, 22, 32, 55, 5, 55, 73]

=={{header|Objeck}}==

{{trans|Java}}

bundle Default {

class Test {

}

}

=={{header|OCaml}}==

a :: (b :: _ as xs) ->

b - a :: forward_difference xs

xs

else

{{out}}

=={{header|Oforth}}==

{{out}}

<pre>

=={{header|PARI/GP}}==

=={{header|Pascal}}==

procedure fowardDifference(list: array of integer);

begin

fowardDifference(a);

{{out}}

<pre>:> ./ForwardDifference

=={{header|Perl}}==

my @s = @_;

map { $s[$_+1] - $s[$_] } 0 .. $#s-1

@a = qw<90 47 58 29 22 32 55 5 55 73>;

{{out}}

<pre> -43 11 -29 -7 10 23 -50 50 18

=={{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>

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

=={{header|PHP}}==

function forwardDiff($anArray, $times = 1) {

}

=={{header|Picat}}==

L = [90, 47, 58, 29, 22, 32, 55, 5, 55, 73],

foreach(I in 1..L.length-1)

Diffs1 := Diffs1 ++ [Diff]

end,

{{out}}

=={{header|PicoLisp}}==

(mapcar - (cdr Lst) Lst) )

(for (L (90 47 58 29 22 32 55 5 55 73) L (fdiff L))

{{out}}

<pre>(90 47 58 29 22 32 55 5 55 73)

=={{header|PL/I}}==

/* Forward differences. */ /* 23 April 2010 */

differences: procedure options (main);

end differences;

=={{header|Plain English}}==

Allocate memory for a fraction thing.

Put the fraction into the fraction thing's fraction.

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.

{{out}}

<pre>

=={{header|Pop11}}==

lvars res = [], prev, el;

if l = [] then

endfor;

res;

=={{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

}

=={{header|PureBasic}}==

If ListSize(a()) <= 1

ClearList(a()): ProcedureReturn

EndIf

{{out}}

<pre>1 [43,-11,29,7,-10,-23,50,-50,-18]

=={{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

[-442, 575, -1329],

[1017, -1904],

===Python 3===

Defining functions for first order and nth order forward difference:

{{Works with|Python|3.7}}

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>9th order forward difference of:

=={{header|Quackery}}==

[ [] swap behead

swap witheach

dup echo say ": "

f-diff echo cr ]

{{out}}

=={{header|R}}==

if ( n == 1 )

a[2:length(a)] - a[1:length(a)-1]

print(forwarddif(v, 9))

=={{header|Racket}}==

#lang racket

(nth-forward-difference 9 '(90 47 58 29 22 32 55 5 55 73))

;; -> '(-2921)

=={{header|Raku}}==

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.

=={{header|REXX}}==

This version allows a specification of the list of numbers and/or which &nbsp; ''order'' &nbsp; to process.

numeric digits 100 /*ensure enough accuracy (decimal digs)*/

parse arg e ',' N /*get a list: ε1 ε2 ε3 ε4 ··· , order */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; when using the default input:

<pre>

===with error checking===

numeric digits 100 /*ensure enough accuracy (decimal digs)*/

parse arg e ',' N /*get a list: ε1 ε2 ε3 ε4 ··· , order */

/*──────────────────────────────────────────────────────────────────────────────────────*/

ser: say; say '***error***'; say arg(1); say; exit 13

'''output''' &nbsp; 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 */

/*──────────────────────────────────────────────────────────────────────────────────────*/

ser: say; say '***error***'; say arg(1); say; exit 13

'''output''' &nbsp; when using the default input:

<pre>

===Version 2===

* Forward differences

* 18.08.2012 Walter Pachl derived from PL/I

End

End

{{out}} for Java's input

<pre>

=={{header|Ring}}==

# Project : Forward difference

see svect

see "}" + nl

Output:

<pre>

{{works with|Ruby|1.8.7}}

s.each_cons(2).collect { |x, y| y - x }

end

def difn(s, n)

n.times.inject(s) { |s, | dif(s) }

{{out|Example usage}}

=={{header|Scala}}==

{{out|Example}}

{{out}}

<pre>

=={{header|Scheme}}==

(if (or (null? lst) (null? (cdr lst)))

'()

xs

(nth-forward-diff (- n 1)

{{out}}

=={{header|Seed7}}==

const func array integer: forwardDifference (in array integer: data) is func

data := forwardDifference(data);

end for;

{{out}}

=={{header|SequenceL}}==

Solution that keeps track of intermediate values:

forwardDifference(x(1), n) := forwardDifferenceHelper(x, n, [x]);

result when n = 0 or size(x) = 1 else

forwardDifferenceHelper(difference, n - 1, result ++ [difference]);

If no intermediate values are needed, the following is sufficient:

forwardDifference(x(1),n) :=

x when n = 0 or size(x) = 1 else

forwardDifference(tail(x) - x[1 ... size(x) - 1], n - 1);

=={{header|Sidef}}==

gather {

for i (0 ..^ arr.end) {

say dif([1, 23, 45, 678]) # => [22, 22, 633]

=={{header|Slate}}==

[

s allButFirst with: s allButLast collect: #- `er

[

(0 below: n) inject: s into: [| :seq :_ | seq forwardDifference]

{{out|Usage}}

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

difference [

^self allButFirst with: self allButLast collect: [ :a :b | a - b ]

s := #(90 47 58 29 22 32 55 5 55 73)

1 to: s size - 1 do: [ :i |

=={{header|SQL}}==

{{works with|SQLite|3.13.0}}

T0 (N, ITEM, LIST, NEW_LIST) AS

(

WHERE NEW_LIST IS NULL

AND LIST <> ''

=={{header|Standard ML}}==

fun nth_forward_difference n xs =

xs

else

{{out}}

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

* Differences

display "Difference order?" _request(k)

=={{header|Swift}}==

return zip(arr.dropFirst(), arr).map({ $0.0 - $0.1 })

}

for diff in (0...9).map({ nthForwardsDifference(of: [90, 47, 58, 29, 22, 32, 55, 5, 55, 73], n: $0) }) {

print(diff)

{{out}}

=={{header|Tcl}}==

set previous [lindex $list 0]

set new [list]

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

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

test program:

#show+

printf/*=*' %0.0f' <

nth_diff6 test_data,

{{out}}

<pre> 291 -151 424 -905

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2008+}}