Seeding / turning a function with multiple arguments into a routine

Questions
#1

Hi All,

I have written some functions that have multiple arguments. Now, I am realizing that I want to seed them individually (without heavily restructuring my code in order to put each function on its own thread). Is there an elegant way to do this given that routine only takes one argument? See below a simplified example of a solution that I came up with. Would be nice to be able to do something like func.seed(1234)

Thanks in advance,

Michael

(
var func, routine, seededFunc;
func = {arg in1, in2; in1 + in2 + 10.rand};
routine = Routine({arg in; loop{in = func.value(*in).yield}});
seededFunc = {arg in1, in2; routine.value([in1, in2])};

routine.randSeed = 100;
10.do({arg i; seededFunc.value(10, i).postln})
)
#2

Are your functions containing any inner routines or scheduling? If not, then you can just wrap:

~wrapper = { |func, seed|
	{ |...args| 
		thisThread.randSeed_(seed);
		func.valueArray(args);
	}
};


f = { |x, y| rrand(x, y) };
g = ~wrapper.(f, 1798);
g.value(3, 5);
#3

Thanks! They are currently not containing inner routines or scheduling, but eventually might be in that one function will be called by another each being on their own thread. Either way, they are getting called several times by different other functions. The example you gave seems to create a new seeded function every time g is called. For example, the following just returns the same thing over and over. Am I missing something?

~wrapper = { |func, seed|
	{ |...args| 
		thisThread.randSeed_(seed);
		func.valueArray(args);
	}
};


f = { |x, y| rrand(x, y) };
g = ~wrapper.(f, 1798);
10.do({value(3, 10).postln});
#4

Yes, sure. So you want the function to encapsulate a series of seeds, I suppose. The easiest way is this maybe:

~wrapper = { |func, seed|
	var nextSeed = Pseed(seed, Pfunc { rrand(1000, 100000) }).asStream;
	{ |...args| 
		thisThread.randSeed_(nextSeed.value);
		func.valueArray(args);
	}
};


f = { |x, y| rrand(x, y) };
g = ~wrapper.(f, 1798);
{ g.value(1, 50) } ! 10
#5

Or, even simpler:

~wrapper = { |func, seed|
	var funcArgs;
	var next = Pseed(seed, Pfunc { func.valueArray(funcArgs) }).asStream;
	{ |...args| 
		funcArgs = args;
		next.value
	}
};


f = { |x, y| rrand(x, y) };
g = ~wrapper.(f, 1798);
{ g.value(1, 50) } ! 10
1 Like
#6

Again… Thanks. That definitely works and the simpler answer is even nicer. Exactly what I was looking for. I guess I still don’t understand how the args of g are getting propagated to f. But it clearly works. And can be used for any arbitrary function. Really great solution.

#7

actually your original idea was very close:

~wrapper = { |func, seed|
	var funcArgs;
	var next = Routine { loop { func.valueArray(funcArgs).yield } };
	next.randSeed_(seed);
	{ |...args| 
		funcArgs = args;
		next.value;
	}
};


f = { |x, y| rrand(x, y) };
g = ~wrapper.(f, 1798);
{ g.value(1, 50) } ! 10
#8

Good to know! But still I am grateful for you helping me get to exactly what I was wanting. Though I was close, I was still not quite there. I love that the wrapper is function agnostic. If you get this message, could you kindly explain how the args of g are getting passed down to the args in f? I really have not seen that paradigm before. If not, not worries. I am really happy about the solution all the same.

#9

I see now that calling g is the same as:
~wrapper.value(f, 1798).value(1, 50)

Which is clear that ~wrapper returns a function which takes in the two arguments. Very cool. I had not thought of that. You can disregard that last question ; )

I would also posit that this could be a really useful trick for a lot of different cases. Would be cool to have this as part of the function class and you could just do func.seed(1234) and it returned that wrapper function.

#10

This is the nice thing you can do with closures. The trick is that the function that you return from the outer function has access to the outer one’s hidden state.

Here is an example with two inner functions:


// make a function that has hidden state
// and that returns two functions for setting or getting it
(
f = {
	var hidden;
	var set = { |x| hidden = x };
	var get = { hidden };
	[set, get]
};
)

a = f.value;

a[1].value; // nil
a[0].value(200);
a[1].value; // 200
#11

Very nice. Thank you : )

#12

You can add methods for existing classes. For this you need to create a file in user support directory and put there something like following:

+ Function {
    seed { |aseed|
        var funcArgs;
        var next = Pseed(aseed, Pfunc { this.valueArray(funcArgs) }).asStream;
        ^{ |...args| 
            funcArgs = args;
            next.value
        }
    }
}

Look for the docs here:
https://doc.sccode.org/Guides/WritingClasses.html
section “External method files”

#13

Thanks! Also good to know. I am always hesitant to mess with classes because you have to recompile the class library and for things I am going to hand to other non-SuperCollider people, I try to make it as easy as possible. On that note, is there a way to programatically recompile the class library?

#14 
thisProcess.recompile
1 Like
#15

Great. I will start extending classes.

#16

I think it isn’t a bad idea to use functions, it can indeed be a bit more complicated to distribute code.

#17

Yeah. For now, I implemented it as a function, but who knows in the future. Either way, it is good to know that you can programatically recompile the class library.