digitalmars.D.learn - functional way doing array stuff/ lambda functions

Namal (10/10) Dec 12 2015 Hello guys,

cym13 (55/65) Dec 12 2015 If you are looking for the functionnal way I'd advise that you

Xinok (10/17) Dec 12 2015 A good post overall but you got reduce wrong. In D, reduce

cym13 (3/22) Dec 12 2015 Damn, I was certain it acted as the two others of the trio... I

cym13 (4/30) Dec 12 2015 Now that I think about it, it's true that it would make no sense

Namal (34/37) Dec 12 2015 Thanks alot, this helped alot. But I have another question

cym13 (15/53) Dec 12 2015 That's because you want to modify it in product passing it by

Namal (26/45) Dec 12 2015 I tried this, it compiles, but crashes when I try to run it:

cym13 (7/34) Dec 13 2015 As cryptic as it is this means that the range you passed to

Namal (77/85) Dec 14 2015 Hmm, that seems different to c++.

visitor (10/15) Dec 14 2015 it crashes because your first t in the loop is an empty array

visitor (19/20) Dec 13 2015 This works for me :

Namal <sotis22 mail.ru> writes:

Hello guys,

I am still uncertain how to do it right when it comes to lambda 
functions. For instance: how do I multiply all the elements in an 
array ?

int product(const ref int[] arr){

	int p = 1;
	foreach(i;arr)
		p*=i;
	return p;
}

Dec 12 2015

cym13 <cpicard openmailbox.org> writes:

On Saturday, 12 December 2015 at 23:10:21 UTC, Namal wrote:
 Hello guys,

 I am still uncertain how to do it right when it comes to lambda 
 functions.

If you are looking for the functionnal way I'd advise that you 
start by
looking up three functions in a language-agnostic way: filter, 
map and
reduce. The filter/map/reduce pattern is very common and most 
other
functions can be emulated using them. For that reason they exist 
in almost
any high-level language. Once you know how to use them well the 
rest is
easier.

As a rule of thumb:

- If you have a set of data (for example integers) and want a 
smaller set of
   data that match some property (for example odd integers) then 
the function
   to use is "filter". Filter will take a function, use that 
function on each
   element of the set one at a time, and if it returns false drop 
the element
   in order to return a new set of data matching the property. For 
example:

     auto oddData = data.filter!(x => x%2 == 1);

- If you have a set of things (say integers) that you want to 
transform into
   another thing without changing the number of elements in your 
set (say you
   want the set of the doubles of each of your integers) then 
"map" is the way
   to go. Map will take a function, apply it to each element of 
the set and
   return the set of the results. For example:

     auto doubles = data.map!(x => x*2);

- If you have a set of data that you want to combine together 
using some rule
   (for exemple, to get their product) in order to reduce it to 
one thing then
   "reduce" is the way to go. It's also called accumulate or fold 
in other
   languages. Reduce will take a function and a seed and pass the 
seed and the
   elements of your set in the function, the result becomming the 
next seed.

 For instance: how do I multiply all the elements in an array ?

 int product(const ref int[] arr){

 	int p = 1;
 	foreach(i;arr)
 		p*=i;
 	return p;
 }

Here is a good case for reduce. In D it returns a lazy range 
(meaning the
result isn't actually computed until you ask for its value), you 
can use
.array to force its evaluation.

So, in your example:

int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     arr = arr.reduce!((p, i) => p*i).array;
}

Dec 12 2015

Xinok <xinok live.com> writes:

On Saturday, 12 December 2015 at 23:36:43 UTC, cym13 wrote:
 ...
 So, in your example:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     arr = arr.reduce!((p, i) => p*i).array;
 }

A good post overall but you got reduce wrong. In D, reduce 
computes and returns the result immediately, not a lazy range. 
The following code is correct:

int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     return arr.reduce!((p, i) => p*i)();
}

Example: http://dpaste.dzfl.pl/fc2c2eab2d02

Dec 12 2015

cym13 <cpicard openmailbox.org> writes:

On Saturday, 12 December 2015 at 23:50:55 UTC, Xinok wrote:
 On Saturday, 12 December 2015 at 23:36:43 UTC, cym13 wrote:
 ...
 So, in your example:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     arr = arr.reduce!((p, i) => p*i).array;
 }

 A good post overall but you got reduce wrong. In D, reduce 
 computes and returns the result immediately, not a lazy range. 
 The following code is correct:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     return arr.reduce!((p, i) => p*i)();
 }

 Example: http://dpaste.dzfl.pl/fc2c2eab2d02

Damn, I was certain it acted as the two others of the trio... I 
stand corrected thanks :-)

Dec 12 2015

cym13 <cpicard openmailbox.org> writes:

On Saturday, 12 December 2015 at 23:59:01 UTC, cym13 wrote:
 On Saturday, 12 December 2015 at 23:50:55 UTC, Xinok wrote:
 On Saturday, 12 December 2015 at 23:36:43 UTC, cym13 wrote:
 ...
 So, in your example:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     arr = arr.reduce!((p, i) => p*i).array;
 }

 A good post overall but you got reduce wrong. In D, reduce 
 computes and returns the result immediately, not a lazy range. 
 The following code is correct:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     return arr.reduce!((p, i) => p*i)();
 }

 Example: http://dpaste.dzfl.pl/fc2c2eab2d02

 Damn, I was certain it acted as the two others of the trio... I 
 stand corrected thanks :-)

Now that I think about it, it's true that it would make no sense 
whatsoever to return a range as reduce is typically used to 
return a single value... At least it makes perfect sense.

Dec 12 2015

Namal <sotis22 mail.ru> writes:

On Sunday, 13 December 2015 at 00:02:11 UTC, cym13 wrote:

 Now that I think about it, it's true that it would make no 
 sense whatsoever to return a range as reduce is typically used 
 to return a single value... At least it makes perfect sense.

Thanks alot, this helped alot. But I have another question

I have two functions:

int[] prim_factors(int n, const ref int[] P){
	
	int[] v;
	
	for(int i; P[i]*P[i]<=n;++i){
		while(n%P[i]==0){
			v~=P[i];
			n/=P[i];
		}
	}
	if(n>1)
		v~=n;
		
	return v.dup.sort.uniq.array;

}


int product(const ref int[] arr){

	int p = 1;
	foreach(i;arr)
		p*=i;
	return p;
}

While vector P contains some primes I get with a prime sieve. So 
if I just try to use those functions like:

writeln(product(prim_factors(10,P)));

I get the error:

function prog.product (ref const(int[]) arr) is not callable 
using argument types (int[])

Why do I have to call it like that first:

	auto v = prim_factors(10,P);
	writeln(product(v));

?

Dec 12 2015

cym13 <cpicard openmailbox.org> writes:

On Sunday, 13 December 2015 at 00:36:29 UTC, Namal wrote:
 On Sunday, 13 December 2015 at 00:02:11 UTC, cym13 wrote:

 Now that I think about it, it's true that it would make no 
 sense whatsoever to return a range as reduce is typically used 
 to return a single value... At least it makes perfect sense.

 Thanks alot, this helped alot. But I have another question

 I have two functions:
j
 int[] prim_factors(int n, const ref int[] P){
 	
 	int[] v;
 	
 	for(int i; P[i]*P[i]<=n;++i){
 		while(n%P[i]==0){
 			v~=P[i];
 			n/=P[i];
 		}
 	}
 	if(n>1)
 		v~=n;
 		
 	return v.dup.sort.uniq.array;

 }


 int product(const ref int[] arr){

 	int p = 1;
 	foreach(i;arr)
 		p*=i;
 	return p;
 }

 While vector P contains some primes I get with a prime sieve. 
 So if I just try to use those functions like:

 writeln(product(prim_factors(10,P)));

 I get the error:

 function prog.product (ref const(int[]) arr) is not callable 
 using argument types (int[])

 Why do I have to call it like that first:

 	auto v = prim_factors(10,P);
 	writeln(product(v));

 ?

That's because you want to modify it in product passing it by 
ref. In order for it to have a reference (and hence be modified 
in place) you need it to have some place in memory of which you 
can take a reference to. This is what rvalues and lvalues are: a 
rvalue is any value that you'd find on the right side of a "=" 
like 3. You can't assign a value to 3, it's a rvalue. On the 
contrary a lvalue is something you'd find on the left side of an 
"=" like v in your example. You can assign a value to v.

Your problem is that product need a lvalue (as you assign 
something to it) but you give it a rvalue instead.

The solution is simple: don't ask arr to be passed by reference 
if you don't intend to modify it.

(I somehow feel like I'm forgetting something there but I can't 
point it, feel free to destroy)

Dec 12 2015

Namal <sotis22 mail.ru> writes:

On Saturday, 12 December 2015 at 23:50:55 UTC, Xinok wrote:
 On Saturday, 12 December 2015 at 23:36:43 UTC, cym13 wrote:
 ...
 So, in your example:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     arr = arr.reduce!((p, i) => p*i).array;
 }

 A good post overall but you got reduce wrong. In D, reduce 
 computes and returns the result immediately, not a lazy range. 
 The following code is correct:

 int product(const ref int[] arr) {
     import std.array:     array;
     import std.algorithm: reduce;

     return arr.reduce!((p, i) => p*i)();
 }

 Example: http://dpaste.dzfl.pl/fc2c2eab2d02


I tried this, it compiles, but crashes when I try to run it:

object.Exception /usr/include/dmd/phobos/std/algorithm/iteration.d(2481):
Enforcement failed
----------------
??:? pure  safe void 
std.exception.bailOut!(Exception).bailOut(immutable(char)[], 
ulong, const(char[])) [0x43a547]
??:? pure  safe bool std.exception.enforce!(Exception, 
bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong) 
[0x43a4c4]
??:? pure  safe int 
std.algorithm.iteration.__T6reduceS305ep1247productFKxAiZ9__lambda2Z.reduce!(const(int)[]).
educe(const(int)[]) [0x43a2ed]
??:? int ep124.product(ref const(int[])) [0x439d49]
??:? _Dmain [0x43a229]
??:? 
_D2rt6dmain211_d_run_mainUiPPaPUAAaZiZ6runAllMFZ9__lambda1MFZv 
[0x448b9a]
??:? void rt.dmain2._d_run_main(int, char**, extern (C) int 
function(char[][])*).tryExec(scope void delegate()) [0x448af0]
??:? void rt.dmain2._d_run_main(int, char**, extern (C) int 
function(char[][])*).runAll() [0x448b56]
??:? void rt.dmain2._d_run_main(int, char**, extern (C) int 
function(char[][])*).tryExec(scope void delegate()) [0x448af0]
??:? _d_run_main [0x448a4d]
??:? main [0x4447ad]
??:? __libc_start_main [0xd9f09ec4]

Dec 12 2015

cym13 <cpicard openmailbox.org> writes:

On Sunday, 13 December 2015 at 03:08:33 UTC, Namal wrote:
 On Saturday, 12 December 2015 at 23:50:55 UTC, Xinok wrote:
 [...]


 I tried this, it compiles, but crashes when I try to run it:

 object.Exception /usr/include/dmd/phobos/std/algorithm/iteration.d(2481):
Enforcement failed
 ----------------
 ??:? pure  safe void 
 std.exception.bailOut!(Exception).bailOut(immutable(char)[], 
 ulong, const(char[])) [0x43a547]
 ??:? pure  safe bool std.exception.enforce!(Exception, 
 bool).enforce(bool, lazy const(char)[], immutable(char)[], 
 ulong) [0x43a4c4]
 ??:? pure  safe int 
 std.algorithm.iteration.__T6reduceS305ep1247productFKxAiZ9__lambda2Z.reduce!(const(int)[]).
educe(const(int)[]) [0x43a2ed]
 ??:? int ep124.product(ref const(int[])) [0x439d49]
 ??:? _Dmain [0x43a229]
 ??:? 
 _D2rt6dmain211_d_run_mainUiPPaPUAAaZiZ6runAllMFZ9__lambda1MFZv 
 [0x448b9a]
 ??:? void rt.dmain2._d_run_main(int, char**, extern (C) int 
 function(char[][])*).tryExec(scope void delegate()) [0x448af0]
 ??:? void rt.dmain2._d_run_main(int, char**, extern (C) int 
 function(char[][])*).runAll() [0x448b56]
 ??:? void rt.dmain2._d_run_main(int, char**, extern (C) int 
 function(char[][])*).tryExec(scope void delegate()) [0x448af0]
 ??:? _d_run_main [0x448a4d]
 ??:? main [0x4447ad]
 ??:? __libc_start_main [0xd9f09ec4]

As cryptic as it is this means that the range you passed to 
reduce is empty. Reduce needs it not to be because as I said it 
needs a seed and as you didn't pass one explicitely as argument 
it tries to take the first element of the range (and fails 
obviously). You can either pass it a seed explicitely or add a 
non-empty check before the return.

Dec 13 2015

Namal <sotis22 mail.ru> writes:

On Sunday, 13 December 2015 at 01:01:07 UTC, cym13 wrote:

 That's because you want to modify it in product passing it by 
 ref.

Hmm, that seems different to c++.


On Sunday, 13 December 2015 at 11:37:50 UTC, cym13 wrote:

 As cryptic as it is this means that the range you passed to 
 reduce is empty. Reduce needs it not to be because as I said it 
 needs a seed and as you didn't pass one explicitely as argument 
 it tries to take the first element of the range (and fails 
 obviously). You can either pass it a seed explicitely or add a 
 non-empty check before the return.


Here is the full code, where I changed the product function. 
Sorry, I don't understand what the difference now and why it 
crashes.

import std.stdio, std.array, std.algorithm;


int product(const ref int[] arr){

	/*int p = 1;
	foreach(i;arr)
		p*=i;
  	return p;*/
  	
  	return arr.reduce!((a, b) => a*b)();

}


int [] prim_sieve(int n){

	bool [] T;
	T.length = n;
	T[0] = true;
	T[1] = true;
	
	for(int i = 2; i*i <= T.length-1;++i){
		for(int j = i*i;j<T.length; j+=i)
			T[j] =true;
	}
	int[] v;
	foreach(int i,t;T)
		if(t==false)
			v~=i;
	return v;
}

int[] prim_factors(int n, const ref int[] P){
	
	int[] v;
	
	for(int i; P[i]*P[i]<=n;++i){
		while(n%P[i]==0){
			v~=P[i];
			n/=P[i];
		}
	}
	if(n>1)
		v~=n;
		
	return v.dup.sort.uniq.array;

}


void bubblesort(ref int[2][] v){

	size_t n = v.length;
	do{
		int newn = 1;
		for(int i = 0;i<n-1; ++i){
			if(v[i][1]>v[i+1][1]){
				auto temp = v[i];
				v[i] = v[i+1];
				v[i+1] = temp;
				newn = i+1;
			}
		}
		n=newn;	
	}
	while(n>1);
}



void main(){
	
	int[] P = prim_sieve(500);
	
	int[2][] v;
	
	foreach(k;1..100001){
		auto t = prim_factors(k,P);
		v~= [k,product(t)];
	}
	
	bubblesort(v);
	
	writeln(v[9999][0]);
}

Dec 14 2015

visitor <visitor gmail.com> writes:

On Monday, 14 December 2015 at 11:45:50 UTC, Namal wrote:
 	
 	foreach(k;1..100001){
 		auto t = prim_factors(k,P);
   		v~= [k,product(t)];
 	}

it crashes because your first t in the loop is an empty array

because 1 is not a prime ( in "prim_sieve" : T[1] = true)
later when you loop starting with k = 1, prim_factors(1,P) gives 
you back an empty array.
so either loop through 2..100001 or guard against the empty array
if (!t.empty) v~= [k, product(t)];

i don't think you need any ref in your functions parameters, as a 
slice is already a reference
http://dlang.org/spec/arrays.html#slicing

Dec 14 2015

visitor <visitor gmail.com> writes:

On Sunday, 13 December 2015 at 03:08:33 UTC, Namal wrote:
 

This works for me :

import std.stdio, std.algorithm, std.range;

int[] prim_factors(int n, const int[] P) {
     int[] v;

     P.filter!( x => x*x <= n).each!( (i) {
	while (n % i == 0) {
	    v ~= i;
	    n /= i;
             if (i == 1) break; // infinite loop otherwise !
	}
     } );

     if (n > 1) v ~= n;

     return v.sort.uniq.array;
}

void main(string[] args) {
     int[] P = [1,2,3,4,5];
     writeln( prim_factors(10, P).reduce!((r, i) => r*i)() );
}

Dec 13 2015

D Programming

C/C++ Programming

Other

digitalmars.D.learn - functional way doing array stuff/ lambda functions