package org.jlayer.app; 

import javax.annotation.processing.Generated;
import java.util.Random;
import org.jlayer.model.*;
import org.jlayer.util.*;

@Generated("org.jlayer.Processor") 
abstract public class ALayer_Output_ extends LayerBase<Output> implements ILayer_Output_ {

   // class ALayer_Output_.D1
   abstract static public class D1 extends LayerBase.D1<Output> implements ILayer_Output_.D1 {
      // constructors 
      public D1(ILayer_Output_.D1 layerD1){ super(layerD1); }
      public D1(Output[] array){ super(array); }
      // field items 
      Layer.D1<Output,MyUtils.Signal> y;
      VectorLayer.D1<Output,MyUtils.Signal> x;
      VectorLayer.D1<Output,MyUtils.Signal> outErr;
      // method items 
      abstract public void initSignals(Random r);
      abstract public void setTarget(Layer.D1<?,Double> target);
      abstract public BasedLayer.D1<Double> getError();
      abstract public void Forward();
      abstract public void Backward(double eta);
   }

   // class ALayer_Output_.D2
   abstract static public class D2 extends LayerBase.D2<Output> implements ILayer_Output_.D2 {
      // constructors 
      public D2(ILayer_Output_.D2 layerD2){ super(layerD2); }
      public D2(Output[][] array){ super(array); }
      // field items 
      Layer.D2<Output,MyUtils.Signal> y;
      VectorLayer.D2<Output,MyUtils.Signal> x;
      VectorLayer.D2<Output,MyUtils.Signal> outErr;
      // method items 
      abstract public void initSignals(Random r);
      abstract public void setTarget(Layer.D2<?,Double> target);
      abstract public BasedLayer.D2<Double> getError();
      abstract public void Forward();
      abstract public void Backward(double eta);
   }

   // class ALayer_Output_.D3
   abstract static public class D3 extends LayerBase.D3<Output> implements ILayer_Output_.D3 {
      // constructors 
      public D3(ILayer_Output_.D3 layerD3){ super(layerD3); }
      public D3(Output[][][] array){ super(array); }
      // field items 
      Layer.D3<Output,MyUtils.Signal> y;
      VectorLayer.D3<Output,MyUtils.Signal> x;
      VectorLayer.D3<Output,MyUtils.Signal> outErr;
      // method items 
      abstract public void initSignals(Random r);
      abstract public void setTarget(Layer.D3<?,Double> target);
      abstract public BasedLayer.D3<Double> getError();
      abstract public void Forward();
      abstract public void Backward(double eta);
   }

// class ALayer_Output_

   // constructors 
   public ALayer_Output_(Output[] array){ super(array); }
   public ALayer_Output_(Output[][] array){ super(array); }
   public ALayer_Output_(Output[][][] array){ super(array); }

   public ALayer_Output_(ILayer_Output_ layer){ super(layer); }
   public ALayer_Output_(ILayer_Output_.D1 layer){ super(layer); }
   public ALayer_Output_(ILayer_Output_.D2 layer){ super(layer); }
   public ALayer_Output_(ILayer_Output_.D3 layer){ super(layer); }

   // field items 
   Layer<Output,MyUtils.Signal> y;
   VectorLayer<Output,MyUtils.Signal> x;
   VectorLayer<Output,MyUtils.Signal> outErr;
   // method items 
   abstract public void initSignals(Random r);
   abstract public void setTarget(Layer<?,Double> target);
   abstract public BasedLayer<Double> getError();
   abstract public void Forward();
   abstract public void Backward(double eta);

} // end of class ALayer_Output_
