#-*- coding: ISO-8859-15 -*-

#=================================================

#  Module  monaldecl.py

#

#  Déclarations pour Monal

#

#  Author: Jean-Luc PLOIX  -  NETRAL

#  Mars 2007

#

#=================================================

from ctypes import Structure, sizeof, c_short, c_ushort, c_double, c_char, \

  c_int, c_byte

import const as C

class TLoopData (Structure):

  _fields_ = [

      ("ILayer", c_short),

      ("INeuron", c_short),

      ("NState", c_short),

      ("Redondancy", c_ushort),

      ("DoNotCreateSynapses", c_ushort),

      ("ExistingNeuron", c_ushort)]

  def __init__(self, layer=0, node=0, order=0, nosynapse=0, existingnode=0):

      Structure.__init__(self)

      self.ILayer = layer

      self.INeuron = node

      self.NState = order

      self.Redondancy = 1

      self.DoNotCreateSynapses = nosynapse

      self.ExistingNeuron = existingnode

#---------------------------------------

class TSynapseData (Structure):

  """Données de lien entre noeuds.Utilisé pour :

  _DeplacerNeurone

  _AbsorberNeurone

  _NouvelleSynapse

  _DetruireSynapse

  _ModifierSynapse"""

          # Pour DeplacerNeurone, si <> 0, l'input de rang

          # RangOrigine est déplacé dans la couche constante

          # avec la value "Value"

          # Pour AbsorberNeurone si <> 0, absorbtion des synapses parents

  _fields_ = [

      ("Size", c_int ),

      ("OriginLayer", c_short),

      ("OriginIndex", c_short),

      ("TargetLayer", c_short),

      ("TargetIndex", c_short),

      ("LinkStyle", c_ushort), # style de lien synaptique. Constantes ls...

      ("InputBool", c_ushort),

      ("OutputBool", c_ushort), # Pour AbsorberNeurone si <> 0, absorbtion des synapses enfants

      ("Value", c_double),

      ("SName", c_char*256),

      ("NetIndex", c_int),

      ("SynIndex", c_int)]

  def __init__(self, name='', originlayer=-2, originindex=-1, targetlayer=-2,

               targetindex=-1, style=0, inputbool=0, outputbool=0, netindex=0, value=0.0):

      Structure.__init__(self)

      self.Size = sizeof(self)

      self.OriginLayer = originlayer

      self.OriginIndex = originindex

      self.TargetLayer = targetlayer

      self.TargetIndex = targetindex

      self.LinkStyle = style

      self.InputBool = inputbool

      self.OutputBool = outputbool

      self.Value = value

      self.SName = name

      self.NetIndex = netindex

      self.SynIndex = netindex

#---------------------------------------

class TNeuronData (Structure):

  """Données de noeud de modèle neuronal. Utilisé pour:

  GetNeuroneInfoEx

  ModifyNetworkEx, avec les styles:

      _ModifierNeurone

      _AjoutNeurone

      _SupprimerNeurone

  et pour les modifications de nom de modèle."""

  _fields_ = [

      ("Size", c_int ),      

      ("Name", c_char*256),

      ("ModelName", c_int),

      ("LayerIndex", c_int),

      ("NeuronIndex", c_int),

      ("Activation", c_int),

      ("NeuronID", c_int),

      ("NeuronType", c_int),     # TNeuronType : (ntNone, ntSigma, ntSigma2, ntPi, ntSigmaPlus)

      ("StylePos", c_int),       # TPositionStyle : (psBegin, psEnd)

      ("NeuronPosition", c_int), # TAddNeuronType : (anDontCare, anConstant, anInput, anOutPut, anOutState)

      ("ActivationPlus", c_int),

      ("IndexNet", c_int),

      ("Value", c_double)]

  def __repr__(self):

      res = ["Object TNeuronData"]

      res.append("Name %s"%self.Name)

      res.append("ModelName %d"% self.NetWorkName)

      res.append("LayerIndex %d"% self.LayerRank)

      res.append("NeuronIndex %d"% self.NeuronRank)

      res.append("Activation %d"% self.Activation)

      res.append("NeuronID %d"% self.NeuronID)

      res.append("NeuronType %d"% self.NeuronType)

      res.append("StylePos %d"% self.StylePos)

      res.append("NeuronPosition %d"% self.NeuronPosition)

      res.append("Value %f"% self.Value)

      res.append("ActivationPlus %d"% self.ActivationPlus)

      res.append("IndexNet %d"% self.IndexNet)

      return '\n'.join(res)

  def __init__(self, name='', isnetname=0, layerindex=-2, nodeindex=-1,

               activation='TANH', nodeID=0, nodetype=1, style=0, nodeposition=0, value=0.0, netindex=-1, Model=None):

      Structure.__init__(self)

      self.Size = sizeof(self)

      if Model:

          self.Name = Model.Name

          self.ModelName = Model.NetWorkName

          self.LayerIndex = Model.LayerRank

          self.NeuronIndex = Model.NeuronRank

          self.Activation = Model.Activation

          self.NeuronID = Model.NeuronID

          self.NeuronType = Model.NeuronType

          self.StylePos = Model.StylePos

          self.NeuronPosition = Model.NeuronPosition

          self.value = Model.value

          self.ActivationPlus = Model.ActivationPlus

          self.IndexNet = Model.IndexNet

      else:

          self.Name = name

          self.ModelName = isnetname

          self.LayerIndex = layerindex

          self.NeuronIndex = nodeindex

          self.Activation = C.getActivIndex(activation)

          self.NeuronID = nodeID

          self.NeuronType = nodetype

          self.StylePos = style

          self.NeuronPosition = nodeposition

          self.value = value

          self.ActivationPlus = 0

          self.IndexNet = netindex

#---------------------------------------

class TLayerData (Structure):

  """Données de couche. Utimisée pour :

  _NouvelleCouche

  _DetruireCouche."""

  _fields_ = [

      ("Size", c_int ),

      ("Index", c_short),

      ("Length", c_short),

      ("Activation", c_short),

      ("NeuronType", c_ushort),

      ("StylePos", c_ushort),

      ("ActivationPlus", c_short),

      ("Name", c_char*256),

      ("NetIndex", c_int)]

  def __init__(self, index=0, len=0, activfunc='TANH', ntype=1):

      Structure.__init__(self)

      self.Size = sizeof(self)

      self.Index = index

      self.Length = len

      self.Activation = C.getActivIndex(activfunc)

      self.NeuronType = ntype

      self.StylePos = 0

      self.ActivationPlus = 0

      self.Name = ''

      self.NetIndex = 0

#---------------------------------------

class TMergeData( Structure ):

  _fields_ = [("Size", c_int ),

              ("FichierSource", c_char*256),

              ("NInputMerge", c_short),

              ("NLayerShift", c_short),

              ("NNodeShift", c_short),

              ("AutoMerge", c_ushort),

              ("PlugIn", c_ushort),

              ("SharedSynapses", c_ushort),

              ("ByName", c_ushort)]

#---------------------------------------

class TNetworkData( Structure ):

  # ancienne structure. Pour compatibilité.

  _fields_ = [("NEntree", c_int),

              ("NOutput", c_int),

              ("NCache", c_int),

              ("AActivCache", c_short)]

  def __init__(self, ninput=0, noutput=0, nhidden=0, activ='IDENTITY'):

      Structure.__init__(self)

      self.NEntree = ninput

      self.NOutput = noutput

      self.NCache = nhidden

      self.AActivCache = C.getActivIndex(activ)

#---------------------------------------

class TModelData( Structure ):

  _fields_ = [( "Size", c_int ),

              ( "NModelInput", c_int ),

              ( "NModelOutput", c_int ),

              ( "NHidden", c_int ),

              ( "AHiddenActiv", c_short ),

              ( "ILayer", c_short ),

              ( "INeuron", c_short ),

              ( "NState", c_short ),

              ( "Redondancy", c_byte ),

              ( "DoNotCreateSynapses", c_byte ),

              ( "ExistingNeuron", c_byte ),

              ( "PolyType", c_short)]

  def __init__(self, input=1, output=1, hidden=2, activfunc="TANH"):

      self.Size = sizeof(self)

      self.NModelInput = input

      self.NModelOutput = output

      self.NHidden = hidden

      self.AHiddenActiv = C.getActivIndex(activfunc)

  def getShort(self):

      return TNetworkData(self.NEntree, self.NOutput, self.NCache, self.AActivCache)

#---------------------------------------