/* C code transfer function for Neuron Network
File : model0tfr.c
Ce code a été crée automatiquement par le module NEURO CODE à partir d'un
modèle neuronal développé avec un outil de la
Suite NEURO ONE
Le présent code source généré par le progiciel NEURO CODE est protégé tant
par les dispositions nationales qu'internationales en matière de droits de
la propriété intellectuelle, dont les droits sont détenus, à titre
exclusif, par la société NETRAL.
L'utilisation et la modification de ce code source est soumise à un contrat
de licence d'utilisation.
La contrefaçon est un délit pénal puni de 2 ans d'emprisonnement et de
150.000 Euros d'amende.
Le modèle du présent code source a fait l'objet d'un dépôt auprès de
l'Agence pour la Protection des Programmes sous le numéro :
IDDN.FR.001.500018.00.S.P.1999.000.20700
NETRAL ne peut en aucun cas être tenu pour responsable des conséquences de
l'utilisation de ce code.
Lisez attentivement le fichier "licfr.txt" joint à ce fichier pour
connaitre vos droits et obligations concernant l'usage de ce code.
Pour obtenir une licence ou tout renseignement complémentaire,
adressez vous à :
NETRAL
14, rue Verdi
9213 Issy-les-Moulineaux
tel : (33) 146 387 512
email: info@netral.com
Date : 25/10/2005
Time : 17:29:52
User : Jean_Luc_PLOIX
Computer : SOPHRONE
Counter : 2
NetworkName : model0
FileName : D:\Program Files\Netral\Data\Exemples\Modeles\Static.NML
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <string.h>
#include "mathplus.h"
#include "readfile.h"
#include "model0tfr.h"
/* Please check name of included header file */
real model0weights[model0SYNAPSES];
long weightinitialized = 0;
real model0min[model0INPUTS + model0OUTPUTS] = {
/* i_0 */ 1,
/* o_0 */ -2.24118};
real model0max[model0INPUTS + model0OUTPUTS] = {
/* i_0 */ 51,
/* o_0 */ 2.11572};
long model0getwinit()
{
return weightinitialized;
}
void model0setwinit(long value)
{
weightinitialized = value;
}
void model0transfer(real *inputs, real *outputs)
/*Module : model0tfr
Method : model0transfer
Visibility : Public
Arguments : inputs: real* -> variables d'entrée
outputs: real* -> variables de sortie
Description: Effectue le transfert par le réseau.
Note : les poids utilisés sont les poids par défat model0weights */
{
model0transferw(model0weights, inputs, outputs);
}
void model0transferw(real *weights, real *inputs, real *outputs)
/*Module : model0tfr
Method : model0transferw
Visibility : Public
Arguments : weights: real* -> les poids courants
inputs: real* -> variables d'entrée
outputs: real* -> variables de sortie
Description: Effectue le transfert par le réseau. */
{
real node[model0NODES];
real potential;
if (!weightinitialized)
model0loadw(NULL);
/* propagation N_Temps_Jours_ */
node[1] = (-1.76635217326557) +
0.0679366220486758*inputs[0];
/* propagation H0_0_ */
potential = weights[0] +
weights[1]*node[1];
node[2] = tanh(potential);
/* propagation H0_1_ */
potential = weights[2] +
weights[3]*node[1];
node[3] = tanh(potential);
/* propagation H0_2_ */
potential = weights[4] +
weights[5]*node[1];
node[4] = tanh(potential);
/* propagation N_Valeur_future_FF_TTC_ */
node[5] = weights[6] +
weights[7]*node[2] +
weights[8]*node[3] +
weights[9]*node[4];
/* propagation Valeur_future_FF_TTC_ */
outputs[0] = 0.273782745098039 +
1.27203791008386*node[5];
}
long model0setweight(long index, real value)
/*Module : model0tfr
Method : model0setweight
Visibility : Public
Arguments : index: long -> indice du poids visé
value: real -> valeur à affecter
Description: affectation d'une valeur de poids.*/
{
model0weights[index] = value;
return 0;
}
char *model0inputname(long index)
/*Module : model0tfr
Method : model0inputname
Visibility : Public
Arguments : index: long -> le rang de l'entrée
Return : char* -> le nom de l'entrée visée
Description: retourne le nom de l'entrée visée. */
{
static char *inames[model0INPUTS] = {
"Temps_Jours_"};
return (index < 0 || index >= model0INPUTS) ? NULL : inames[index];
}
char *model0outputname(long index)
/*Module : model0tfr
Method : model0outputname
Visibility : Public
Arguments : index: long -> le rang de la sortie
Return : char* -> le nom de la sortie visée
Description: retourne le nom de la sortie visée. */
{
static char *onames[model0OUTPUTS] = {
"Valeur_future_FF_TTC_"};
return (index < 0 || index >= model0OUTPUTS) ? NULL : onames[index];
}
char *model0weightname(long index)
/*Module : model0tfr
Method : model0weightname
Visibility : Public
Arguments : index: long -> le rang du poids
Return : char* -> le nom du poids visé
Description: retourne le nom du poids visé. */
{
static char *wnames[model0SYNAPSES] = {
"w(0)",
"w(1)",
"w(2)",
"w(3)",
"w(4)",
"w(5)",
"w(6)",
"w(7)",
"w(8)",
"w(9)"};
return (index < 0 || index >= model0SYNAPSES) ? NULL : wnames[index];
}
real *model0inputrange(long index)
/*Module : model0tfr
Method : model0inputrange
Visibility : Public
Arguments : index: long -> le rang de l'entrée
Return : real* -> pointeur sur le tableau des valeurs Min et Max
Description: retourne les valeurs min et max de l'entrée visée. Ces valeurs
sont celles constatées lors de l'apprentissage */
{
static real inrange[model0INPUTS][2] = {
{1, 51}};
return (index < 0 || index >= model0INPUTS) ? NULL : inrange[index];
}
real *model0outputrange(long index)
/*Module : model0tfr
Method : model0outputrange
Visibility : Public
Arguments : index: long -> le rang de la sortie
Return : real* -> pointeur sur le tableau des valeurs Min et Max
Description: retourne les valeurs min et max de la sortie visée. Ces valeurs
sont celles constatées lors de l'apprentissage */
{
static real outrange[model0OUTPUTS][2] = {
{-2.24118, 2.11572}};
return (index < 0 || index >= model0OUTPUTS) ? NULL : outrange[index];
}
real *model0getweightini(long index)
/*Module : model0tfr
Method : model0getweightini
Visibility : Public
Arguments : index: indice du poids dont on lit les paramètres d'initialisation
Return : Pointer on a double double.
Description: lecture des paramètres d'initialisation d'un poids */
{
static real iniweight[model0SYNAPSES][2] = {
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1},
{0, 0.1}};
return (index < 0 || index >= model0SYNAPSES) ? NULL : iniweight[index];
}
long model0loadw(char* filename)
/*Module : model0tfr
Method : model0loadw
Visibility : Public
Arguments : filename: *char -> nom du fichier ASCII de poids
Return : long -> 0 si OK, sinon code d'erreur
1 -> impossible d'ouvrir le fichier
2 -> le fichier de poids ne comporte pas le bon nombre de poids
3 -> la lecture n'a pas lu le bon nombre de poids. Dans ce cas,
attention aux poids qui ont été modifiés
Description: charge les valeurs des poids lies dans le fichier désigné. Si le
nom de fichier transmis est NULL, la recherche est faite dans le fichier par défaut
"model0w.txt"*/
/* Loading weights from ASCII file */
{
FILE *file;
char buffer[BUFFERSIZE];
char bufname[BUFFERSIZE];
char* tok;
long n;
long ok = 0;
long cumul = 0;
long start = 0;
if (filename)
strncpy(bufname, filename, BUFFERSIZE-1);
else
strcat(strcpy(bufname, MODEL), "w.txt");
file = fopen(bufname, "r");
if (file)
{
while ((!feof(file)) && (!ok))
{
if (fgets(buffer, BUFFERSIZE-1, file) && (buffer[0] != ';') && (buffer[0] != '\n') && (!strncmp(buffer, WEIGHTS, strlen(WEIGHTS))))
{
if (fgets(buffer, BUFFERSIZE-1, file))
{
tok = strtok(buffer, "=");
if (!strcmp(tok, COUNT))
{
tok = strtok(NULL, "=");
if ((tok) && (!isalpha(tok[0])))
{
n = atoi(supbackline(tok));
ok = (n == model0SYNAPSES);
}
}
}
}
}
if (ok)
{
while (!feof(file) && (cumul < model0SYNAPSES))
{
if (fgets(buffer, BUFFERSIZE-1, file) && (buffer[0] != ';') && (buffer[0] != '\n'))
{
if (!isalpha(buffer[0]))
{
start = 1;
model0setweight(cumul, atof(supbackline(buffer)));
}
}
if (start) cumul++;
}
fclose(file);
if (cumul == model0SYNAPSES)
{
weightinitialized = 1;
return 0;
}
else
return 3;
}
else
return 2;
}
else
return 1;
}
long model0savew(char* filename, char* comment)
{
FILE *file;
char bufname[BUFFERSIZE];
long i;
if (filename)
strncpy(bufname, filename, BUFFERSIZE-1);
else
strcat(strcpy(bufname, MODEL), "w.txt");
file = fopen(bufname, "w");
if (file)
{
if ((comment) && (comment[0]))
fprintf(file, "%s\n", comment);
fprintf(file, "%s\n", WEIGHTS);
fprintf(file, "%s=%ld\n", COUNT, model0SYNAPSES);
for (i=0; i < model0SYNAPSES; i++)
fprintf(file, "%20.16E\n", model0weights[i]);
fclose(file);
return 0;
}
else
return 1;
}
NETRAL - Neuro Code 6