block_graph/builtin/
mod.rs

1impl Decompose for Alignment{
2	fn compose(decomposition:Self::Decomposition)->Self{
3		match decomposition{0=>Self::Center,1=>Self::Left,2=>Self::Right,_=>panic!("unknown alignment number")}
4	}
5	fn decompose(self)->Self::Decomposition{
6		match self{Self::Center=>0,Self::Left=>1,Self::Right=>2}
7	}
8	fn decompose_cloned(&self)->Self::Decomposition{
9		match self{Self::Center=>0,Self::Left=>1,Self::Right=>2}
10	}
11	type Decomposition=usize;
12}
13impl Decompose for OnMismatch{// TODO with explicit u64 decomposition this could fit a f32 in the pad
14	fn compose(decomposition:Self::Decomposition)->Self{
15		match decomposition%10{0=>Self::Error,1=>Self::Pad(Alignment::compose(decomposition/10)),2=>Self::Truncate(Alignment::compose(decomposition/10)),_=>panic!("unknown mismatch number")}
16	}
17	fn decompose(self)->Self::Decomposition{
18		match self{Self::Error=>0,Self::Pad(a)=>a.decompose()*10+1,Self::Truncate(a)=>a.decompose()*10+2}
19	}
20	fn decompose_cloned(&self)->Self::Decomposition{self.clone().decompose()}
21	type Decomposition=usize;
22}
23impl Decompose for ReductionMode{
24	fn compose(decomposition:u64)->Self{
25		match decomposition>>32{0=>Self::Component,1=>Self::Dim(decomposition as i32),2=>Self::Tensor,_=>panic!("unknown reduction mode number")}
26	}
27	fn decompose(self)->Self::Decomposition{
28		match self{Self::Component=>0,Self::Dim(x)=>(1_u64<<32)|(x as u32 as u64),Self::Tensor=>2<<32}
29	}
30	fn decompose_cloned(&self)->Self::Decomposition{self.clone().decompose()}
31	type Decomposition=u64;
32}
33impl Default for Alignment{
34	fn default()->Self{Self::Left}
35}
36impl Default for OnMismatch{
37	fn default()->Self{Self::Error}
38}
39impl Default for ReductionMode{
40	fn default()->Self{Self::Component}
41}
42impl<M:AI<M::Output,M::Output>+Op> Sequential<Vec<M>>{
43	/// appends the module to the sequence, then returns the sequence
44	pub fn with_next<A:Into<M>>(mut self,m:A)->Self{
45		self.inner_mut().push(m.into());
46		self
47	}
48}
49impl<A:AI<R,S>+Op<Output=S>,B:AI<S,T>+Op<Output=T>,C:AI<T,U>+Op<Output=U>,D:AI<U,V>+Op<Output=V>,E:AI<V,W>+Op<Output=W>,F:AI<W,X>+Op<Output=X>,G:AI<X,Y>+Op<Output=Y>,H:AI<Y,Z>,R,S,T,U,V,W,X,Y,Z> AI<R,Z> for Sequential<(A,B,C,D,E,F,G,H)>{
50	fn forward(&self,input:R)->Z{
51		let (a,b,c,d,e,f,g,h)=self.inner();
52		h.forward(g.forward(f.forward(e.forward(d.forward(c.forward(b.forward(a.forward(input))))))))
53	}
54	fn forward_mut(&mut self,input:R)->Z{
55		let (a,b,c,d,e,f,g,h)=self.inner_mut();
56		h.forward(g.forward_mut(f.forward_mut(e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input))))))))
57	}
58}
59impl<A:AI<S,T>+Op<Output=T>,B:AI<T,U>+Op<Output=U>,C:AI<U,V>+Op<Output=V>,D:AI<V,W>+Op<Output=W>,E:AI<W,X>+Op<Output=X>,F:AI<X,Y>+Op<Output=Y>,G:AI<Y,Z>,S,T,U,V,W,X,Y,Z> AI<S,Z> for Sequential<(A,B,C,D,E,F,G)>{
60	fn forward(&self,input:S)->Z{
61		let (a,b,c,d,e,f,g)=self.inner();
62		g.forward(f.forward(e.forward(d.forward(c.forward(b.forward(a.forward(input)))))))
63	}
64	fn forward_mut(&mut self,input:S)->Z{
65		let (a,b,c,d,e,f,g)=self.inner_mut();
66		g.forward_mut(f.forward_mut(e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input)))))))
67	}
68}
69impl<A:AI<T,U>+Op<Output=U>,B:AI<U,V>+Op<Output=V>,C:AI<V,W>+Op<Output=W>,D:AI<W,X>+Op<Output=X>,E:AI<X,Y>+Op<Output=Y>,F:AI<Y,Z>,T,U,V,W,X,Y,Z> AI<T,Z> for Sequential<(A,B,C,D,E,F)>{
70	fn forward(&self,input:T)->Z{
71		let (a,b,c,d,e,f)=self.inner();
72		f.forward(e.forward(d.forward(c.forward(b.forward(a.forward(input))))))
73	}
74	fn forward_mut(&mut self,input:T)->Z{
75		let (a,b,c,d,e,f)=self.inner_mut();
76		f.forward_mut(e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input))))))
77	}
78}
79impl<A:AI<U,V>+Op<Output=V>,B:AI<V,W>+Op<Output=W>,C:AI<W,X>+Op<Output=X>,D:AI<X,Y>+Op<Output=Y>,E:AI<Y,Z>,U,V,W,X,Y,Z> AI<U,Z> for Sequential<(A,B,C,D,E)>{
80	fn forward(&self,input:U)->Z{
81		let (a,b,c,d,e)=self.inner();
82		e.forward(d.forward(c.forward(b.forward(a.forward(input)))))
83	}
84	fn forward_mut(&mut self,input:U)->Z{
85		let (a,b,c,d,e)=self.inner_mut();
86		e.forward_mut(d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input)))))
87	}
88}
89impl<A:AI<V,W>+Op<Output=W>,B:AI<W,X>+Op<Output=X>,C:AI<X,Y>+Op<Output=Y>,D:AI<Y,Z>,V,W,X,Y,Z> AI<V,Z> for Sequential<(A,B,C,D)>{
90	fn forward(&self,input:V)->Z{
91		let (a,b,c,d)=self.inner();
92		d.forward(c.forward(b.forward(a.forward(input))))
93	}
94	fn forward_mut(&mut self,input:V)->Z{
95		let (a,b,c,d)=self.inner_mut();
96		d.forward_mut(c.forward_mut(b.forward_mut(a.forward_mut(input))))
97	}
98}
99impl<A:AI<W,X>+Op<Output=X>,B:AI<X,Y>+Op<Output=Y>,C:AI<Y,Z>,W,X,Y,Z> AI<W,Z> for Sequential<(A,B,C)>{
100	fn forward(&self,input:W)->Z{
101		let (a,b,c)=self.inner();
102		c.forward(b.forward(a.forward(input)))
103	}
104	fn forward_mut(&mut self,input:W)->Z{
105		let (a,b,c)=self.inner_mut();
106		c.forward_mut(b.forward_mut(a.forward_mut(input)))
107	}
108}
109impl<A:AI<W,Z>+AI<X,Y>,W,X,Y,Z> AI<W,Z> for SetType<A,X,Y>{
110	fn forward(&self,input:W)->Z{self.inner().forward(input)}
111	fn forward_mut(&mut self,input:W)->Z{self.inner_mut().forward_mut(input)}
112}
113impl<A:AI<X,X>+Op<Output=X>,X> Op for Sequential<&[A]>{
114	type Output=X;
115}
116impl<A:AI<X,X>+Op<Output=X>,X> Op for Sequential<&mut [A]>{
117	type Output=X;
118}
119impl<A:AI<X,X>+Op<Output=X>,X> Op for Sequential<Vec<A>>{
120	type Output=X;
121}
122impl<A:AI<X,X>,X:Clone> Iterator for Autoregression<A,X>{
123	fn next(&mut self)->Option<Self::Item>{
124		let output=self.state.clone();
125		self.state=Some(self.ai.forward_mut(self.state.take().unwrap()));
126		output
127	}
128	fn size_hint(&self)->(usize,Option<usize>){(usize::MAX,None)}
129	type Item=X;
130}
131impl<A:AI<X,X>,X> AI<X,X> for Sequential<&[A]>{
132	fn forward(&self,input:X)->X{self.inner().iter().fold(input,|x,a|a.forward(x))}
133}
134impl<A:AI<X,X>,X> AI<X,X> for Sequential<&mut [A]>{
135	fn forward(&self,input:X)->X{self.inner().iter().fold(input,|x,a|a.forward(x))}
136	fn forward_mut(&mut self,input:X)->X{self.inner_mut().iter_mut().fold(input,|x,a|a.forward_mut(x))}
137}
138impl<A:AI<X,X>,X> AI<X,X> for Sequential<Vec<A>>{
139	fn forward(&self,input:X)->X{self.inner().iter().fold(input,|x,a|a.forward(x))}
140	fn forward_mut(&mut self,input:X)->X{self.inner_mut().iter_mut().fold(input,|x,a|a.forward_mut(x))}
141}
142impl<A:AI<X,Y>+Op<Output=Y>,B:AI<Y,Z>,X,Y,Z> AI<X,Z> for Sequential<(A,B)>{
143	fn forward(&self,input:X)->Z{
144		let (a,b)=self.inner();
145		b.forward(a.forward(input))
146	}
147	fn forward_mut(&mut self,input:X)->Z{
148		let (a,b)=self.inner_mut();
149		b.forward_mut(a.forward_mut(input))
150	}
151}
152impl<A:AI<X,Y>+Op<Output=Y>,I:IntoIterator<Item=X>,J:FromIterator<Y>,X,Y> AI<I,J> for Map<A>{
153	fn forward(&self,input:I)->J{
154		let a=self.inner();
155		input.into_iter().map(|x|a.forward(x)).collect()
156	}
157	fn forward_mut(&mut self,input:I)->J{
158		let a=self.inner_mut();
159		input.into_iter().map(|x|a.forward_mut(x)).collect()
160	}
161}
162impl<A:AI<X,Y>+Op<Output=Y>,X:Clone+OpsAdd<Y,Output=Z>,Y:Into<Z>,Z> AI<X,Z> for Residual<A>{
163	fn forward(&self,x:X)->Z{
164		let apply=self.apply;
165		let f=&self.inner;
166
167		if apply{x.clone()+f.forward(x)}else{f.forward(x).into()}
168	}
169	fn forward_mut(&mut self,x:X)->Z{
170		let apply=self.apply;
171		let f=&mut self.inner;
172
173		if apply{x.clone()+f.forward_mut(x)}else{f.forward_mut(x).into()}
174	}
175}
176impl<A:AI<X,Y>,X,Y:Clone,const N:usize> AI<X,[Y;N]> for Duplicate<A>{
177	fn forward(&self,input:X)->[Y;N]{
178		let y=self.inner().forward(input);
179		[0;N].map(|_|y.clone())
180	}
181	fn forward_mut(&mut self,input:X)->[Y;N]{
182		let y=self.inner_mut().forward_mut(input);
183		[0;N].map(|_|y.clone())
184	}
185}
186impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y)> for Duplicate<A>{
187	fn forward(&self,input:X)->(Y,Y){
188		let y=self.inner().forward(input);
189		(y.clone(),y)
190	}
191	fn forward_mut(&mut self,input:X)->(Y,Y){
192		let y=self.inner_mut().forward_mut(input);
193		(y.clone(),y)
194	}
195}
196impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y)> for Duplicate<A>{
197	fn forward(&self,input:X)->(Y,Y,Y){
198		let y=self.inner().forward(input);
199		(y.clone(),y.clone(),y)
200	}
201	fn forward_mut(&mut self,input:X)->(Y,Y,Y){
202		let y=self.inner_mut().forward_mut(input);
203		(y.clone(),y.clone(),y)
204	}
205}
206impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y)> for Duplicate<A>{
207	fn forward(&self,input:X)->(Y,Y,Y,Y){
208		let y=self.inner().forward(input);
209		(y.clone(),y.clone(),y.clone(),y)
210	}
211	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y){
212		let y=self.inner_mut().forward_mut(input);
213		(y.clone(),y.clone(),y.clone(),y)
214	}
215}
216impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y)> for Duplicate<A>{
217	fn forward(&self,input:X)->(Y,Y,Y,Y,Y){
218		let y=self.inner().forward(input);
219		(y.clone(),y.clone(),y.clone(),y.clone(),y)
220	}
221	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y){
222		let y=self.inner_mut().forward_mut(input);
223		(y.clone(),y.clone(),y.clone(),y.clone(),y)
224	}
225}
226impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y,Y)> for Duplicate<A>{
227	fn forward(&self,input:X)->(Y,Y,Y,Y,Y,Y){
228		let y=self.inner().forward(input);
229		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
230	}
231	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y,Y){
232		let y=self.inner_mut().forward_mut(input);
233		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
234	}
235}
236impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y,Y,Y)> for Duplicate<A>{
237	fn forward(&self,input:X)->(Y,Y,Y,Y,Y,Y,Y){
238		let y=self.inner().forward(input);
239		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
240	}
241	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y,Y,Y){
242		let y=self.inner_mut().forward_mut(input);
243		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
244	}
245}
246impl<A:AI<X,Y>,X,Y:Clone> AI<X,(Y,Y,Y,Y,Y,Y,Y,Y)> for Duplicate<A>{
247	fn forward(&self,input:X)->(Y,Y,Y,Y,Y,Y,Y,Y){
248		let y=self.inner().forward(input);
249		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
250	}
251	fn forward_mut(&mut self,input:X)->(Y,Y,Y,Y,Y,Y,Y,Y){
252		let y=self.inner_mut().forward_mut(input);
253		(y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y.clone(),y)
254	}
255}
256impl<A:AI<X,Y>,X,Y> Op for SetType<A,X,Y>{
257	type Output=Y;
258}
259impl<A:AI<X,Y>,X,Y> SetType<A,X,Y>{
260	accessible_inner!(inner:A);
261	pub fn new(inner:A)->Self{
262		Self{inner,phantom:PhantomData}
263	}
264}
265impl<A:Decompose,X:Decompose> Decompose for Autoregression<A,X>{
266	fn compose(decomposition:Self::Decomposition)->Self{
267		Self{ai:A::compose(decomposition.0),state:Some(X::compose(decomposition.1))}
268	}
269	fn decompose(self)->Self::Decomposition{(self.ai.decompose(),self.state.unwrap().decompose())}
270	fn decompose_cloned(&self)->Self::Decomposition{(self.ai.decompose_cloned(),self.state.as_ref().unwrap().decompose_cloned())}
271	type Decomposition=(A::Decomposition,X::Decomposition);
272}
273impl<A:Decompose,X,Y> Decompose for SetType<A,X,Y>{
274	fn compose(decomposition:Self::Decomposition)->Self{
275		Self{inner:A::compose(decomposition),phantom:PhantomData}
276	}
277	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
278	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
279	type Decomposition=A::Decomposition;
280}
281impl<A:Decompose> Decompose for Duplicate<A>{
282	fn compose((inner,times):Self::Decomposition)->Self{
283		Self{inner:A::compose(inner),times}
284	}
285	fn decompose(self)->Self::Decomposition{(self.inner.decompose(),self.times)}
286	fn decompose_cloned(&self)->Self::Decomposition{(self.inner.decompose_cloned(),self.times)}
287	type Decomposition=(A::Decomposition,usize);
288}
289impl<A:Decompose> Decompose for Sequential<A>{
290	fn compose(decomposition:Self::Decomposition)->Self{
291		Self{inner:A::compose(decomposition)}
292	}
293	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
294	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
295	type Decomposition=A::Decomposition;
296}
297impl<A:Decompose> Decompose for Map<A>{
298	fn compose(decomposition:Self::Decomposition)->Self{
299		Self{inner:A::compose(decomposition)}
300	}
301	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
302	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
303	type Decomposition=A::Decomposition;
304}
305impl<A:Decompose> Decompose for Residual<A>{
306	fn compose((decomposition,apply):Self::Decomposition)->Self{
307		Self{apply,inner:A::compose(decomposition)}
308	}
309	fn decompose(self)->Self::Decomposition{(self.inner.decompose(),self.apply)}
310	fn decompose_cloned(&self)->Self::Decomposition{(self.inner.decompose_cloned(),self.apply)}
311	type Decomposition=(A::Decomposition,bool);
312}
313impl<A:Op<Output=Y>,Y> Op for Residual<A>{
314	type Output=Y;
315}
316impl<A:Decompose> Decompose for Zip<A>{
317	fn compose(decomposition:Self::Decomposition)->Self{
318		Self{inner:A::compose(decomposition)}
319	}
320	fn decompose(self)->Self::Decomposition{self.inner.decompose()}
321	fn decompose_cloned(&self)->Self::Decomposition{self.inner.decompose_cloned()}
322	type Decomposition=A::Decomposition;
323}
324impl<A:IntoSequence<M>,M:AI<M::Output,M::Output>+Op> IntoSequence<M> for Duplicate<A> where Duplicate<M>:Into<M>{
325	fn into_sequence(self)->Sequential<Vec<M>>{
326		let mut s=self.inner.into_sequence();
327		if let Some(l)=s.inner_mut().pop(){
328			s.inner_mut().push(Duplicate{inner:l,times:self.times}.into())
329		}
330		s
331	}
332}
333impl<A:IntoSequence<M>,M:AI<M::Output,M::Output>+Op> IntoSequence<M> for Map<A> where Map<M>:Into<M>{
334	fn into_sequence(self)->Sequential<Vec<M>>{
335		Sequential::new(self.inner.into_sequence().into_inner().into_iter().map(|inner|Map{inner}.into()).collect())
336	}
337}
338impl<A:IntoSequence<M>,M:AI<M::Output,M::Output>+Op> IntoSequence<M> for Sequential<Vec<A>>{//TODO into sequence for tuple
339	fn into_sequence(self)->Sequential<Vec<M>>{
340		Sequential{inner:self.into_inner().into_iter().flat_map(|a|a.into_sequence().into_inner()).collect()}
341	}
342}
343impl<A:Op<Output=S>,B:AI<S,T>+Op<Output=T>,C:AI<T,U>+Op<Output=U>,D:AI<U,V>+Op<Output=V>,E:AI<V,W>+Op<Output=W>,F:AI<W,X>+Op<Output=X>,G:AI<Y,Z>+Op<Output=Y>,H:AI<Y,Z>+Op<Output=Z>,S,T,U,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E,F,G,H)>{
344	type Output=Z;
345}
346impl<A:Op<Output=T>,B:AI<T,U>+Op<Output=U>,C:AI<U,V>+Op<Output=V>,D:AI<V,W>+Op<Output=W>,E:AI<W,X>+Op<Output=X>,F:AI<Y,Z>+Op<Output=Y>,G:AI<Y,Z>+Op<Output=Z>,T,U,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E,F,G)>{
347	type Output=Z;
348}
349impl<A:Op<Output=U>,B:AI<U,V>+Op<Output=V>,C:AI<V,W>+Op<Output=W>,D:AI<W,X>+Op<Output=X>,E:AI<Y,Z>+Op<Output=Y>,F:AI<Y,Z>+Op<Output=Z>,U,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E,F)>{
350	type Output=Z;
351}
352impl<A:Op<Output=V>,B:AI<V,W>+Op<Output=W>,C:AI<W,X>+Op<Output=X>,D:AI<Y,Z>+Op<Output=Y>,E:AI<Y,Z>+Op<Output=Z>,V,W,X,Y,Z> Op for Sequential<(A,B,C,D,E)>{
353	type Output=Z;
354}
355impl<A:Op<Output=W>,B:AI<W,X>+Op<Output=X>,C:AI<Y,Z>+Op<Output=Y>,D:AI<Y,Z>+Op<Output=Z>,W,X,Y,Z> Op for Sequential<(A,B,C,D)>{
356	type Output=Z;
357}
358impl<A:Op<Output=X>,B:AI<Y,Z>+Op<Output=Y>,C:AI<Y,Z>+Op<Output=Z>,X,Y,Z> Op for Sequential<(A,B,C)>{
359	type Output=Z;
360}
361impl<A:Op<Output=Y>,B:AI<Y,Z>+Op<Output=Z>,Y,Z> Op for Sequential<(A,B)>{
362	type Output=Z;
363}
364impl<A:Op<Output=Y>,Y> Op for Duplicate<A>{
365	type Output=(Y,Y);
366}
367impl<A:Op<Output=Y>,Y> Op for Map<A>{
368	type Output=Vec<Y>;
369}
370impl<A:UnwrapInner> UnwrapInner for Duplicate<A>{
371	fn unwrap_inner(self)->Self::Inner{self.inner.unwrap_inner()}
372	type Inner=A::Inner;
373}
374impl<A:UnwrapInner> UnwrapInner for Map<A>{
375	fn unwrap_inner(self)->Self::Inner{self.inner.unwrap_inner()}
376	type Inner=A::Inner;
377}
378impl<A,X> Autoregression<A,X>{
379	accessible_inner!(ai:A);
380	pub fn new<W>(mut ai:A,input:W)->Self where A:AI<W,X>+AI<X,X>,X:Clone{
381		let state=Some(ai.forward_mut(input));
382		Self{ai,state}
383	}
384}
385impl<A> Duplicate<A>{
386	accessible_inner!(inner:A);
387	/// creates a new duplicate module from the inner value
388	pub fn from_inner(inner:A)->Self{
389		Duplicate{inner,times:2}
390	}
391	/// creates a new duplicate module from the inner value
392	pub fn new(inner:A)->Self{
393		Duplicate{inner,times:2}
394	}
395	/// returns the suggested number of times to duplicate
396	pub fn times(&self)->usize{self.times}
397	/// replaces the inner value
398	pub fn with_inner<B>(&self,inner:B)->Duplicate<B>{Duplicate::from_inner(inner).with_times(self.times)}
399	/// sets the suggested number of times to duplicate for a variable sized output like a vec. fixed array outputs of other lengths will still be allowed
400	pub fn with_times(mut self,times:usize)->Self{
401		self.times=times;
402		self
403	}
404}
405impl<A> Sequential<A>{
406	accessible_inner!(inner:A);
407	pub fn new(inner:A)->Self{
408		Self{inner}
409	}
410}
411impl<A> Map<A>{
412	accessible_inner!(inner:A);
413	pub fn new(inner:A)->Self{
414		Self{inner}
415	}
416}
417impl<A> Zip<A>{
418	accessible_inner!(inner:A);
419	pub fn new(inner:A)->Self{
420		Self{inner}
421	}
422}
423impl<F:Fn(X)->Y,M:AI<M::Output,M::Output>+Op,X,Y> IntoSequence<M> for Apply<F,X,Y> where Self:Into<M>{
424	fn into_sequence(self)->Sequential<Vec<M>>{vec![self.into()].sequential()}
425}
426impl<F:Fn(X)->Y,X,Y> AI<X,Y> for Apply<F,X,Y>{
427	fn forward(&self,input:X)->Y{(&self.inner)(input)}
428}
429impl<F:Fn(X)->Y,X,Y> Op for Apply<F,X,Y>{
430	type Output=Y;
431}
432/// creates accessor functions for the inner value
433macro_rules! accessible_inner{
434	($field:ident:$type:ident)=>(
435		/// references the inner value
436		pub fn inner(&self)->&$type{&self.$field}
437		/// references the inner value
438		pub fn inner_mut(&mut self)->&mut $type{&mut self.$field}
439		/// returns the inner value
440		pub fn into_inner(self)->$type{self.$field}
441	);
442}
443macro_rules! zip_tuple{
444	($(($($type:ident),+):($($input:ident),+)->($($output:ident),+)),*)=>($(
445		impl<$($type:AI<$input,$output>,$input,$output),+> AI<($($input),+),($($output),+)> for Zip<($($type),+)>{
446			#[allow(non_snake_case)]
447			fn forward(&self,($($input),+):($($input),+))->($($output),+){
448				let ($($type),+)=self.inner();
449				($($type.forward($input)),+)
450			}
451			#[allow(non_snake_case)]
452			fn forward_mut(&mut self,($($input),+):($($input),+))->($($output),+){
453				let ($($type),+)=self.inner_mut();
454				($($type.forward_mut($input)),+)
455			}
456		}
457		impl<$($type:Op<Output=$output>,$output),+> Op for Zip<($($type),+)>{
458			type Output=($($output),+);
459		}
460	)*);
461}
462#[cfg(test)]
463mod tests{
464	#[test]
465	fn acc_q_vec(){
466		let op=().fix_type::<Vec<f32>>().acc_q(0.5);
467		let x:Vec<f32>=vec![1.0,1.0,1.0,1.0,1.0];
468		let y:Vec<f32>=op.forward(x);
469		assert_eq!(y,[1.9375_f32,1.875,1.75,1.5,1.0]);
470	}
471	#[test]
472	fn mse_vec(){
473		let op=().fix_type::<Vec<f32>>().squared_error().mean();
474		let x:(Vec<f32>,Vec<f32>)=(vec![0.0,0.5,1.5],vec![-2.0,1.5,5.5]);
475		let y:f32=op.forward(x);
476		assert_eq!(y,7.0);
477	}
478	use super::*;
479}
480#[derive(Clone,Copy,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)]
481/// alignment
482pub enum Alignment{Center,Left,Right}
483#[derive(Clone,Copy,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)]
484/// shape mismatch handling
485pub enum OnMismatch{Error,Pad(Alignment),Truncate(Alignment)}
486#[derive(Clone,Copy,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)]
487/// reduction mode
488pub enum ReductionMode{Component,Dim(i32),Tensor}
489/// creates an operation that applies the closure
490pub fn apply<F:Fn(X)->Y,X,Y>(f:F)->Apply<F,X,Y>{
491	Apply{inner:f,phantom:PhantomData}
492}
493/// layers representing important mathematical operations
494pub mod math;
495/// layers relating to reinforcement learning
496pub mod reinforcement;
497/// layers relating to cross entropy or softmax
498pub mod soft;
499/// layers like cat or swap dims that change the organization or structure of tensors
500pub mod structural;
501
502impl<A:AI<X,Y>+IntoSequence<M>,M:AI<M::Output,M::Output>+Op,X,Y> IntoSequence<M> for SetType<A,X,Y>{
503	fn into_sequence(self)->Sequential<Vec<M>>{self.into_inner().into_sequence()}
504}
505impl<A:AI<X,Y>+UnwrapInner,X,Y> UnwrapInner for SetType<A,X,Y>{
506	fn unwrap_inner(self)->Self::Inner{self.into_inner().unwrap_inner()}
507	type Inner=A::Inner;
508}
509
510#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
511/// applies a closure to the input// TODO more closure layers maybe
512pub struct Apply<F:Fn(X)->Y,X,Y>{inner:F,phantom:PhantomData<fn(X)->Y>}
513#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
514/// autoregressive inference
515pub struct Autoregression<A,X>{ai:A,state:Option<X>}
516#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
517/// module for cloning things
518pub struct Duplicate<A>{inner:A,times:usize}
519#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
520/// wraps to apply to every element of a vector
521pub struct Map<A>{inner:A}
522#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
523/// layer to add an optional residual connection
524pub struct Residual<A>{apply:bool,inner:A}
525#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
526/// layer for removing dimensions with size 1
527pub struct SqueezeLayer{dim:i32}
528#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
529/// wrapper for applying ai modules sequentially
530pub struct Sequential<A>{inner:A}
531#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
532/// fixes the output type of a layer for a particular input type.
533pub struct SetType<A,X,Y>{inner:A,phantom:PhantomData<fn(X)->Y>}
534#[derive(Clone,Copy,Debug,Default,Deserialize,Serialize)]
535/// wraps to apply each function
536pub struct Zip<A>{inner:A}
537use {accessible_inner,zip_tuple};
538use crate::{
539	AI,Decompose,IntoSequence,Op,UnwrapInner
540};
541use serde::{Deserialize,Serialize};
542use std::{
543	iter::FromIterator,marker::PhantomData,ops::Add as OpsAdd
544};
545zip_tuple!((A,B):(W,X)->(Y,Z),(A,B,C):(U,V,W)->(X,Y,Z),(A,B,C,D):(S,T,U,V)->(W,X,Y,Z),(A,B,C,D,E):(Q,R,S,T,U)->(V,W,X,Y,Z),(A,B,C,D,E,F):(O,P,Q,R,S,T)->(U,V,W,X,Y,Z),(A,B,C,D,E,F,G):(M,N,O,P,Q,R,S)->(T,U,V,W,X,Y,Z),(A,B,C,D,E,F,G,H):(K,L,M,N,O,P,Q,R)->(S,T,U,V,W,X,Y,Z));
block_graph/builtin/mod.rs

block_graph/builtin/
mod.rs
