Anonymous user
Apply a callback to an array: Difference between revisions
revert spam
mNo edit summary |
(revert spam) |
||
Line 1:
{{task}}
== [[Ada]] ==
[[Category:Ada]]
'''Tested With:'''
* [[Gnat GPL 2005]]
** Amd-64bit-3500
with Ada.Text_Io;
Line 93:
{
int i;
for(i = 0; i < len; i
{
callback(i, array[i]);
Line 116:
'''Platform:''' [[.NET]]
'''Language Version:''' 2.0
'''Compiler:''' [[Visual C sharp|Visual C#]] 2005
using System;
Line 157 ⟶ 155:
}
==[[C plus plus|C
[[Category:C plus plus]]
'''Compiler:''' [[GNU Compiler Collection]] 4.1.1
Line 173 ⟶ 171:
int ary[]={1,2,3,4,5};
//stl for_each
std::for_each(ary,ary
return 0;
}
Line 232 ⟶ 230:
vector<int> ary(10);
int i = 0;
for_each(ary.begin(), ary.end(), _1 =
transform(ary.begin(), ary.end(), ostream_iterator<int>(cout, " "), _1 * _1); // square and output
Line 269 ⟶ 267:
(defvar *a* (vector 1 2 3))
(map-into *a* #'1
==[[E]]==
Line 303 ⟶ 301:
: map ( addr n fn -- )
-rot cells bounds do i @ over execute i ! cell
Example usage:
create data 1 , 2 , 3 , 4 , 5 ,
data 5 ' 1
==[[Fortran]]==
Line 334 ⟶ 332:
{square * . [id, id]}
& square: <1,2,3,4,5>
== [[Haskell]] ==
[[Category:Haskell]]
'''Interpreter''' : [[GHC | GHCi]]
'''Compiler''' : [[GHC]]
let square x = x*x
let values = [1..10]
map square values
Using list comprehension to generate a list of the squared values
[square x | x <- values]
Using function composition to create a function that will print the squares of a list
let printSquares = putStr.unlines.map (show.square)
printSquares values
== [[IDL]] ==
[[Category:IDL]]
Hard to come up with an example that isn't completely contrived. IDL doesn't really distinguish between a scalar and an array; thus
b = a^3
will yield a scalar if a is scalar or a vector if a is a vector or an n-dimensional array is a is an n-dimensional array
== [[JavaScript]] ==
[[Category:JavaScript]]
Portable technique:
function map(a, func) {
for (var i in a)
a[i] = func(a[i]);
}
var a = [1, 2, 3, 4, 5];
map(a, function(v) { return v * v; });
With the [http://w3future.com/html/beyondJS/ BeyondJS] library:
var a = (1).to(10).collect(Math.pow.curry(undefined,2));
With Firefox 2.0:
function cube(num) {
return Math.pow(num, 3);
}
var numbers = [1, 2, 3, 4, 5];
//get results of calling cube on every element
var cubes1 = numbers.map(cube);
//display each result in a separate dialog
cubes1.forEach(alert);
//array comprehension
var cubes2 = [cube(n) for each (n in numbers)];
var cubes3 = [n * n * n for each (n in numbers)];
==[[Lua]]==
[[Category:Lua]]
Say we have an array:
myArray = {1, 2, 3, 4, 5}
A map function for this would be
map = function(f, data)
local result = {}
for k,v in ipairs(data) do
result[k] = f(v)
end
return result
end
Together with our array and and a square function this yields:
myFunc = function(x) return x*x end
print(unpack( map(myFunc, myArray) ))
--> 1 4 9 16 25
If you used pairs() instead of ipairs(), this would even work on a hash table in general.
== [[OCaml]] ==
[[Category:OCaml]]
This function is part of the standard library:
Array.map
Usage example:
let square x = x * x;;
let values = Array.init 10 ((+) 1);;
Array.map square values;;
==[[Perl]]==
[[Category:Perl]]
# create array
my @a = (1, 2, 3, 4, 5);
# create callback function
sub mycallback {
return 2 * shift;
}
# use array indexing
my $i;
for ($i = 0; $i < scalar @a; $i++) {
print "mycallback($a[$i]) = ", mycallback($a[$i]), "\n";
}
# using foreach
foreach my $x (@a) {
print "mycallback($x) = ", mycallback($x), "\n";
}
# using map (useful for transforming an array)
my @b = map mycallback($_), @a; # @b is now (2, 4, 6, 8, 10)
# and the same using an anonymous function
my @c = map { $_ * 2 } @a; # @c is now (2, 4, 6, 8, 10)
# use a callback stored in a variable
my $func = \&mycallback;
my @d = map &{$func}($_), @a; # @d is now (2, 4, 6, 8, 10)
==[[PHP]]==
[[Category:PHP]]
function cube($n)
{
return($n * $n * $n);
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
== [[PL/SQL]] ==
[[Category:PL/SQL]]
'''Interpreter''' : Oracle compiler
set serveroutput on
declare
type myarray is table of number index by binary_integer;
x myarray;
i pls_integer;
begin
-- populate array
for i in 1..5 loop
x(i) := i;
end loop;
i :=0;
-- square array
loop
i := i + 1;
begin
x(i) := x(i)*x(i);
dbms_output.put_line(x(i));
exception
when no_data_found then exit;
end;
end loop;
end;
/
==[[Pop11]]==
[[Category:Pop11]]
;;; Define a procedure
define proc(x);
printf(x*x, '%p,');
enddefine;
;;; Create array
lvars ar = { 1 2 3 4 5};
;;; Apply procedure to array
appdata(ar, proc);
If one wants to create a new array consisting of transformed values
then procedure mapdata may be more convenient.
== [[Python]] ==
[[Category:Python]]
<pre>
def square(n):
return n * n
numbers = [1, 3, 5, 7]
squares1 = [square(n) for n in numbers] # list comprehension
squares2 = map(square, numbers) # discouraged nowadays
squares3 = [n * n for n in numbers] # no need for a function,
# anonymous or otherwise
isquares = (n * n for n in numbers) # iterator, lazy
</pre>
==[[Ruby]]==
[[Category:Ruby]]
# You could use a traditional "for i in arr" approach like below:
for i in [1,2,3,4,5] do
puts i**2
end
# Or you could the more preferred ruby way of an iterator (which is borrowed from SmallTalk)
[1,2,3,4,5].each{ |i| puts i**2 }
# To create a new array of each value squared
[1,2,3,4,5].map{ |i| i**2 }
==[[Scala]]==
[[Category:Scala]]
val l = List(1,2,3,4)
l.foreach {i => Console.println(i)}
Same for an array
val a = Array(1,2,3,4)
a.foreach {i => Console.println(i)}
// Or for an externally defined function
def doSomething(in: int) = {Console.println("Doing something with "+in)}
l.foreach(doSomething)
There is also a ''for'' syntax, which is internally rewritten to call foreach. A foreach method must be define on ''a''
for(val i <- a) Console.println(i)
It is also possible to apply a function on each item of an list to get a new list (same on array and most collections)
val squares = l.map{i => i * i} //returns List(1,4,9,16)
Or the equivalent ''for'' syntax, with the additional keyword ''yield'', map is called instead of foreach
val squares = for (val i <- l) yield i * i
== [[Scheme]] ==
[[Category:Scheme]]
(define (square n) (* n n))
(define x #(1 2 3 4 5))
(map square (vector->list x))
A single-line variation
(map (lambda (n) (* n n)) '(1 2 3 4 5))
For completeness, the <tt>map</tt> function (which is R5RS standard) can be coded as follows:
(define (map f L)
(if (null? L)
L
(cons (f (car L)) (map f (cdr L)))))
== [[Smalltalk]] ==
[[Category:Smalltalk]]
| anArray |
anArray = #( 1 2 3 4 5 )
anArray do: [ :x | Transcript nextPut: x * x ]
== [[Tcl]] ==
[[Category:Tcl]]
If I wanted to call "<tt>myfunc</tt>" on each element of <tt>dat</tt> and <tt>dat</tt> were a list:
foreach var $dat { myfunc $var }
if <tt>dat</tt> were an array, however:
foreach var [array names dat] { myfunc $dat($var) }
== [[Toka]] ==
[[Category:Toka]]
( array count function -- )
{
variable| array fn |
[ i 1- array @ ] is I
[ fn ! swap array ! [ I get-element fn @ invoke I put-element ] +iterate ]
} is map-array
( Build an array )
5 cells is-array a
10 0 a put-element
11 1 a put-element
12 2 a put-element
13 3 a put-element
14 4 a put-element
( Add 1 to each item in the array )
a 5 ` 1+ map-array
| |||