/*
r=array
f=function
n=ammount
p=point or power
b=bottom
t=top
s=step 
i=initial value
w=weight
*/

R {

*nf {arg n...z; var res, fres; res=[]; fres=[]; 
	(z.size>1).if({
		n.do({arg i; z.do({arg it; fres = fres.add(it.value(i))});	
		res=res.add(fres); fres=[]})},
		{n.do({arg i; res=res.add(z.at(0).value(i)); fres=[]})});^res}

*rNORM{arg r,t=1; var max, min; max=r.maxItem; min=r.minItem;
	(-1*min>max).if({^(r/(-1*min/t))},{^(r/(max/t))})}

*rINT{arg r; ^r.collect({arg it; it.asInteger})}

*nnoDIV {arg divisions, num, off; var f,res,toff,half,start,it; res=[];
	f={arg ar; half=ar.at(1)/2; start=ar.at(0);
			toff=(half*off/50).rand*(2.rand+1*2-3);
			[[start,half+toff],[start+half+toff, half-toff]]};
	it=[[0,num]];
	divisions.do({it.do({arg item; res=res++f.value(item)}); it=res; res=[]});
	^it}
	
*nnoDIVINT {arg divisions, num, off; var f,res,toff,half,start,it; res=[];
	f={arg ar; half=ar.at(1)/2; start=ar.at(0);
			toff=(half*off/50).rand*(2.rand+1*2-3);
				[[start,round(half+toff,1).asInteger],
				[round(start+half+toff,1).asInteger,round(half-toff,1).asInteger]]};
	it=[[0,num]];
	divisions.do({it.do({arg item; res=res++f.value(item)}); it=res; res=[]});
	^it}
	
*nnonooDIV8INST {arg divisions, ntime,toff, nenergy, eoff,voff; 
	var res,prob,t,energy; res=[]; 
	energy=R.nnoDIV(divisions,nenergy, eoff).collect({arg it; it.at(1)}); 
	//energy.postln; "".postln;
	8.do({res=res++[R.nnoDIVINT(divisions,ntime,toff)]});
	(2**divisions).asInteger.do({arg sect;
		prob=R.nnoDIV(3, energy.at(sect), voff).collect({arg it; it.at(1)});
		//prob.postln; 
		prob.do({arg item,inst;
res.put(inst, res.at(inst).copy.put(sect,res.at(inst).at(sect).copy.add(item)))
})})
	^res}
//r=R.nnonooDIV8INST(2,1000000,2,10,5,10);
//r.do({arg it; it.postln})

*rfINST{arg all,alg; var partres,res, prob, start, dur, energy, div; res=[];
all.do({arg block, i;
	start=block.at(0); dur=block.at(1); energy=block.at(2);
	div=energy.corf;
	(div==0).if({partres=alg.value(energy);
	res=R.rprCOPY(res, start, partres)},
		{partres=R.rfINST(
			R.nnoDIVINT(div,dur,10.rand).collect(
			{arg mr; [mr.at(0)+start, mr.at(1), 0]}), {alg.value(energy)});
		res=R.rprCOPY(res, start, partres)})})
^res}

*rfINSTS{arg all,alg; var partres,res, prob, start, dur, energy, div,pan,ed; 
	res=[Signal[],Signal[]];
all.do({arg block, i;
	start=block.at(0); dur=block.at(1); energy=block.at(2);
	div=energy.corf;
	(div==0).or(dur<50).if({partres=M.sig(alg.value(energy)); pan=1.0.rand;
		res=[(R.rprCOPY(res.at(0), start, partres)*pan),
		(R.rprCOPY(res.at(1), start+rrand(0,15), partres)*(1-pan))];},
		{ed=R.nnoDIV(div,energy,10.rand);
		partres=R.rfINSTS(
			R.nnoDIVINT(div,dur,10.rand).collect(
			{arg mr, i; [mr.at(0)+start, mr.at(1), ed.at(i).at(1)]}), {alg.value(energy)});		
		res=[R.rprCOPY(res.at(0), start, partres.at(0)),
			R.rprCOPY(res.at(1), start, partres.at(1))];
		})
	});
		     
^res}

*rfINSTQ{arg all,alg; var partres,res, prob, start, dur, energy, div,pan1,pan2; 
res=[Signal[],Signal[],Signal[],Signal[]]; 
all.do({arg block, i;
	start=block.at(0); dur=block.at(1); energy=block.at(2);
	div=energy.corf;
	(div==0).if({partres=M.sig(alg.value(energy));
	pan1=1.0.rand;pan2=1.0.rand;
	res=[R.rprCOPY(res.at(0), start+2.rand, partres)*(pan1*pan2),
			R.rprCOPY(res.at(1), start+2.rand, partres)*((1-pan1)*pan2),
			R.rprCOPY(res.at(2), start+2.rand, partres)*((1-pan1)*(1-pan2)),
			R.rprCOPY(res.at(3), start+2.rand, partres)*(pan1*(1-pan2))]},
		{partres=R.rfINSTQ(
			R.nnoDIVINT(div,dur,10.rand).collect(
			{arg mr; [mr.at(0)+start, mr.at(1), 0]}), {alg.value(energy)});
		res=res.collect({arg chan, chi; R.rprCOPY(chan, start, partres.at(chi))})})})
^res}



*rnKILL{arg r...n; var res, matrix, c; matrix=[]; 
			n.do({arg it; c=[1]; (it-1).do({c=c.add(0)}); matrix=matrix++c});
			res=r.reject({arg it, i; (matrix.wrapAt(i)==1).if({true},{false})});^res}

*nrDICE{arg n,ws; var d, ds, ms, p, r, am, res; r=[]; res=[]; d=ws.size; ds=Array.fill(d,0);
	ms=Array.fill(d, {arg i; am=2**(i); r=Array.fill(am, 0);p=(am/2-1).asInteger; r.put(p,1); r});	
	n.do({arg i; ds.put(0, ws.at(0).rand);
		(d-1).do({arg di; (ms.at(di+1).wrapAt(i)==1).if({ds.put(di+1, ws.at(di).rand)})});	
	res=res.add(ds.sum)}); ^res}  

*nrDICE2{arg n,ws; var d, ds, ms, p, r, am, res; r=[]; res=[]; d=ws.size; ds=Array.fill(d,0);
	ms=Array.fill(d, {arg i; am=i*2+1; r=Array.fill(am, 0);p=(am-1).asInteger; r.put(p,1); r});	
	n.do({arg i; ds.put(0, ws.at(0).rand);
		(d-1).do({arg di; (ms.at(di+1).wrapAt(i)==1).if({ds.put(di+1, ws.at(di).rand)})});	
	res=res.add(ds.sum)}); ^res} 
	
*rfnITER{arg ar, func, n; var it; it=ar.copy; n.do({it = func.value(it)}); ^it}

*rffITERWHILE{arg ar,func,boolf; var it,test; it=ar.copy; test=true;
	{test}.while({test=boolf.value(it.size); it = func.value(it)});^it}
//R.rffITERWHILE([1,2,3],{arg ar; ar.copy++(ar+2)},{arg x; x<20}).postln

*rrPIP{arg ar, timear, der = 0; var pFunc, func, res, a, dern, times; res=[];
	pFunc={arg n, valn, der0; a = (valn - (der0 * n))/(n**2); dern = (2 * a * n) + der0;
			{arg x; [(a * x * x) + (der0 * x), dern]}};
	ar.copyRange(0,ar.size-2).do({arg it,i;
		times=timear.wrapAt(i);
		func = pFunc.value(times, ar.at(i+1)-it, der);
		times.do({arg x; res = res.add(func.value(x).at(0) + it)});		
		der = func.value(0).at(1); }); res=res.add(ar.last); ^res}

*rrLIP{arg ar,timear; var a,res,times,diff; res=[];	
	ar.copyRange(0,ar.size-2).do({arg it,i; times=timear.wrapAt(i); diff=ar.at(i+1)-it;	
	times.do({arg x; res=res.add(diff/times*x+it)});});
	res=res.add(ar.last); ^res}

*rrSIP{arg ar,timear; var a,times,res; res=[];	
	ar.do({arg it,i; times=timear.wrapAt(i);a=pi/times; times.do({arg x; res=res.add(it*sin(a*x))})});
	res=res.add(0);^res}

*rrCIP{arg ar, timear; var a, b, c, res, times; res=[];	
	ar.do({arg it, i; times=timear.wrapAt(i); a= it*(-0.5); b=2*pi/times;
	times.do({arg x; res=res.add(a*cos(b*x)-a)})});
	res=res.add(0);^res}

*frUZI{arg func, argar; var res, fres; res=[]; argar.do({arg it; fres=func.valueArray(it); 
	(fres.isNumber).if({res=res.add(fres)},{res=res++fres})}); ^res}

*frrUZI{arg func, argar, timear; var res, fres; res=[]; argar.size.do({arg i; timear.at(i).do
	({fres=func.valueArray(argar.at(i));(fres.isNumber).if({res=res.add(fres)},{res=res++fres})})}); ^res}

*rprCOPY{arg rd, p, r; var res,rdsize,rsize; res=[]; rdsize=rd.size; rsize=r.size;	
(p<rdsize).if({//while        	
(p==0).if({(rdsize>rsize).if({res=(rd+r)++rd.copyRange(rsize, rdsize-1);^res}, //p=0 big rd
		{res=(rd+r)++r.copyRange(rdsize, rsize-1);^res})}, //p=0 big r
{((rsize+p-1)<rdsize).if({res=rd.copyRange(0,p-1) 		//p>0 big rd
	++(rd.copyRange(p,rdsize-1)+r) ++rd.copyRange(p+rsize, rdsize-1);^res},	                   
{res=rd.copyRange(0,p-1)++(rd.copyRange(p,rdsize-1)+r)				//p>0 big r
	++r.copyRange(rdsize-p, rsize-1);^res})})},
{(p==rdsize).if({res=rd++r; ^res}, //after
	{res=rd++Array.fill(p-rdsize,0)++r;^res})})}

}

F {

*aPLUSb {arg you; ^{arg me; me+you}}

*aTIMESb {arg you; ^{arg me; me*you}}

*btnLINE {arg b,t,n; var val, step;step=t-b/(n-1);  val=b-step; ^{val = val+step; val}}

*nLINEbt {arg n; var val=0, it=0, step; ^{arg b, t; step=t-b/(n-1); it=b+val;val = val+step; it}}

*btnpLPCURVE{arg b,t,n,p; var step, val; step = ((10**(t-b))**(1/p) - 1) /(n-1); 
					val = 1 - step; ^{val = val + step;(b + (log10(val ** p)))}}

*btRAND{arg b,t;^{rrand(b, t)}}

*orRAND{arg offset, range; ^{rrand(offset-range, offset+range)}}

*rANDbt{^{arg b, t; rrand(b, t)}}

*rANDor{^{arg offset, range; rrand(offset-range, offset+range)}}

*siRWALKbt {arg step, initval; var it, c; it=initval;^{arg a, b; (a>b).if({c=a; a=b; b=c});
((it+step)>b).if({it=it-step; it}, {((it-step)<a).if({it=it+step; it}, [{it=it+step;it}, {it=it-step;it}].choose.value)})}}

*sibtRWALK {arg step, initval, a, b; var it, c; it=initval;  (a>b).if({c=a; a=b; b=c});
^{((it+step)>b).if({it=it-step; it}, {((it-step)<a).if({it=it+step; it}, [{it=it+step;it}, {it=it-step;it}].choose.value)})}}

*pLOGPr {arg p; ^{arg r; r.collect({arg it;log10(it**p)})}}

*btMIRRORr {arg bot, top; ^{arg ar; ar.collect({arg it; (it<bot).if({bot-it+bot},{(it>top).if({top-(it-top)},{it})})})}}

*btCLIPr{arg bot, top; ^{arg ar; ar.collect({arg it; (it<bot).if({bot},{(it>top).if({top},{it})})})}}

*fpiCOPYr{arg f, p, init=0; var res, fres, fsize; res=[];	
	(p<0).if({^{arg ar; var size, sp; fres=f.value(ar);fsize=fres.size;size=ar.size; //before
			sp=(ar.size*p).asInteger;
		((-1*fsize)>=sp).if({res=fres++Array.fill(-1*fsize-sp, {init})++ar; res}, //far back
		{((fsize+sp)<size).if({
		res=fres.copyRange(0,-1*sp-1)++(fres.copyRange(-1*sp,fsize-1)+ar) //big ar
			++ar.copyRange(fsize+sp,size-1); res},
		{res=fres.copyRange(0,-1*sp-1)++(fres.copyRange(-1*sp,fsize-1)+ar) //big fres
			++fres.copyRange(size-sp,fsize-1); res})})}},
	{(p<1).if({^{arg ar; var size, sp;size=ar.size;fres=f.value(ar);fsize=fres.size;  //while
			sp=(ar.size*p).asInteger;
		(sp==0).if({(size>fsize).if({res=(ar+fres)++ar.copyRange(fsize, size-1);res}, //p=0 big ar
						{res=(ar+fres)++fres.copyRange(size, fsize-1);res})}, //p=0 big fres
		{((fsize+sp-1)<size).if({res=ar.copyRange(0,sp-1)++(ar.copyRange(sp,size-1)+fres) //sp>0 big ar
			++ar.copyRange(sp+fsize, size-1);res},	                   
		{res=ar.copyRange(0,sp-1)++(ar.copyRange(sp,size-1)+fres)				//sp>0 big fres
			++fres.copyRange(size-sp, fsize-1);res})})}},
	{(p==1).if({^{arg ar; var fres; fres=f.value(ar);res=ar++fres; res}},
	{^{arg ar; var size, sp; fres=f.value(ar);fsize=fres.size; size=ar.size; 
			sp=(ar.size*p).asInteger; //after
		res=ar++Array.fill(sp-size,init)++fres;res}})})})}

*fpMIRRORr{arg f, p; var res; res=[]; (p>1).if({p=1},{(p<(-1)).if({p=(-1)})}); (p==0).if({^{[]}},
	(p>0).if({^{arg ar; (ar.size*p).asInteger.do({arg i; res=res.add(ar.at(i))}); ar=res.copy; 
			res=f.value(res);res.pop;ar++res.reverse}},
		{^{arg ar; var size; size=ar.size; (size*p*(-1)).asInteger.do({arg i;res=res.add(ar.at(size-i-1))}); 
			ar=f.value(res); ar=ar.reverse; ar.pop; ar++res}}))}

*rIKILLr{arg noti; ^{arg r; r.reject({arg it, i; noti.includes(i)})}}
}

M {

*info{arg ar,name = "array";name.post;" contains ".post;ar.size.post;" items, greatest item is ".post;
ar.maxItem.post;", smallest item is ".post;ar.minItem.postln; (ar.size>20).if
({"[".post;  forBy(0, (ar.size-4), (ar.size/7).asInteger, {arg i;ar.at(i).post;",".post;ar.at(i+1).post;",".post;
ar.at(i+2).post;"...".post}); ar.last.post;"]".postln},{ar.postln})}

*listen{arg ar, name="array"; var snd; (ar.size/44100).post; " sec.".postln;snd= Signal.newClear(ar.size); 
	ar.size.do({arg i; snd.put(i,ar.at(i))}); snd.normalize.plot.play}

*draw{arg ar, name; var snd; M.info(ar,name);snd= Signal.newClear(ar.size); ar.size.do({arg i; 
snd.put(i,ar.at(i))}); snd.plot}

*hist{arg ar,n; var res; res=[];  ar=ar.sort;
	ar=R.rnKILL(ar,2,1,1,1,1,1,1,1,1,1,1); 
	ar.doAdjacentPairs({arg a,b; res=res.add(1/(b-a))});
	n.do({
		ar=[];
		res.doAdjacentPairs({arg a,b; ar=ar.add(a+b/2)});
		res=[];
		ar.doAdjacentPairs({arg a,b; res=res.add(a+b/2)})
		});	
	M.draw(res)}

*t {arg time; var d; d=Date.getDate;(time==0).if({^[d.minute, d.second]},
	{(d.minute-time.at(0)).post;"min ".post;(d.second-time.at(1)).post;"sec".postln; ^0})}

*sig{arg ar; var snd; snd= Signal.newClear(ar.size); ar.size.do({arg i; 
	snd.put(i,ar.at(i))}); ^snd}

*aofsToFile{arg aofs,path="W:test"; var file;
	file=SoundFile.new.headerFormat_('AIFF').sampleFormat_('16 big endian signed'); 
	file.read(path);
	file.data_(aofs);
	file.write(path);	
	}

*toFile{arg ar, point, pan, path="W:test"; var file, fl, fr, resl,resr;
	file=SoundFile.new.headerFormat_('AIFF').sampleFormat_('16 big endian signed'); 
	file.read(path).if({fl=file.data.at(0); fr=file.data.at(1)},{fl=Signal[];fr=Signal[]});
	resl=R.rprCOPY(fl,point,M.sig(ar*(1-pan)));
	resr=R.rprCOPY(fr,point,M.sig(ar*pan));
	file.data_([resl,resr]);
	file.write(path);	
	}
*toFile2{arg ar, point, pan, path="W:test"; var file, fl, fr, resl,resr;
	file=SoundFile.new.headerFormat_('AIFF').sampleFormat_('16 big endian signed'); 
	file.readHeader(path).if({fl=file.data.at(0); fr=file.data.at(1)},{fl=Signal[];fr=Signal[]});
	resl=R.rprCOPY(fl,point,M.sig(ar*(1-pan)));
	resr=R.rprCOPY(fr,point,M.sig(ar*pan));
	file.data_([resl,resr]);
	file.write(path);	
	}
	

}