/* N E U R A L N E M R E @ E */
#include "neuro.h"
#ifdef __cplusplus
extern "C"{
#endif
/* Initialisation. Moved from the header file. */
extern float Reyni_alpha=(float)0.9;
extern int sequence_randomiser=0;
extern float fixed_weight=(float)1.0;
extern float rude_w_T=(float)2.0, rude_w_F=(float)2.0, rude_n_T=(float)1.2, rude_n_F=(float)1.2;
extern float fine_w_T=(float)1.5, fine_w_F=(float)1.5, fine_n_T=(float)1.1, fine_n_F=(float)1.1;
extern char node_output_type='l'; /* l means linear */
extern float node_output_e_exponent=5.0;
extern float treasureholdadd=0.0;
extern struct fuzzy_object *BIAS_fuzzy_object=NULL;
/* Kod simulacije neuralne mre`e koriste}i fuzzy varijable, sve te`ine ~vora predstavljaju fuzzy varijablu, svaka te`ina je zapravo klasa, a pointer *set ukazuje na ~vor s kojega se uzima ulaz. Operator *actual svakog ~vora (fuzzy_object) pokazuje na te`inu preko koje je stigla najve}a pobuda. Izlaz iz ~vora je pohranjen u varijabli notes. */
/* "T"* MA"T"(int number_of_elements) where "T" means type and can be 'KL'=koef_learn, 'Le'=Level, 'N'=neuron, 'BW'=backwinner, 'PBW'=p_backwinner, 'FSNN'=fuzzy_state_neural_network, 'BPCM'=BP_correction_memory or any of previous letters with (one or more) prefix 'p' =pointer on */
/* Pointer to reserved (allocated) space is returned! */
/* It deals with memory allocation (testmalloc) request for number_of_elements locations of type "T". In the case there is no available memory request is being repeated up to 101 times and if there is still lack of testfree memory unsucessfull end of process is caused (exit(1)). */
koef_learn* MAKL(long int number_of_elements)
{
koef_learn *head;
int i=0;
do
head=(koef_learn*)testmalloc((size_t)number_of_elements*sizeof(koef_learn));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,101);
return(head);
} /* ; */
Level* MALe(long int number_of_elements)
{
Level *head;
int i=0;
do
head=(Level*)testmalloc((size_t)number_of_elements*sizeof(Level));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,102);
return(head);
} /* ; */
neuron* MAN(long int number_of_elements)
{
neuron *head;
int i=0;
do
head=(neuron*)testmalloc((size_t)number_of_elements*sizeof(neuron));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,103);
return(head);
} /* ; */
backwinner* MABW(long int number_of_elements)
{
backwinner *head;
int i=0;
do
head=(backwinner*)testmalloc((size_t)number_of_elements*sizeof(backwinner));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,104);
return(head);
} /* ; */
p_backwinner* MAPBW(long int number_of_elements)
{
p_backwinner *head;
int i=0;
do
head=(p_backwinner*)testmalloc((size_t)number_of_elements*sizeof(p_backwinner));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,105);
return(head);
} /* ; */
fuzzy_state_neural_network* MAFSNN(long int number_of_elements)
{
fuzzy_state_neural_network *head;
int i=0;
do
head=(fuzzy_state_neural_network*)testmalloc((size_t)number_of_elements*sizeof(fuzzy_state_neural_network));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,106);
return(head);
} /* ; */
BP_correction_memory* MABPCM(long int number_of_elements)
{
BP_correction_memory *head;
int i=0;
do
head=(BP_correction_memory*)testmalloc((size_t)number_of_elements*sizeof(BP_correction_memory));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,107);
return(head);
} /* ; */
neuron_population* MANP(long int number_of_elements)
{
neuron_population *head;
int i=0;
do
head=(neuron_population*)testmalloc((size_t)number_of_elements*sizeof(neuron_population));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,108);
return(head);
} /* ; */
neural_subsystem* MANSS(long int number_of_elements)
{
neural_subsystem *head;
int i=0;
do
head=(neural_subsystem*)testmalloc((size_t)number_of_elements*sizeof(neural_subsystem));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,109);
return(head);
} /* ; */
neural_system* MANS(long int number_of_elements)
{
neural_system *head;
int i=0;
do
head=(neural_system*)testmalloc((size_t)number_of_elements*sizeof(neural_system));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,110);
return(head);
} /* ; */
neuron_type_descriptor* MANTD(long int number_of_elements)
{
neuron_type_descriptor *head;
int i=0;
do
head=(neuron_type_descriptor*)testmalloc((size_t)number_of_elements*sizeof(neuron_type_descriptor));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,111);
return(head);
} /* ; */
set_of_neuron_types* MASNT(long int number_of_elements)
{
set_of_neuron_types *head;
int i=0;
do
head=(set_of_neuron_types*)testmalloc((size_t)number_of_elements*sizeof(set_of_neuron_types));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,112);
return(head);
} /* ; */
nucleotide_base* MANB(long int number_of_elements)
{
nucleotide_base *head;
int i=0;
do
head=(nucleotide_base*)testmalloc((size_t)number_of_elements*sizeof(nucleotide_base));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,113);
return(head);
} /* ; */
gene* MAG(long int number_of_elements)
{
gene *head;
int i=0;
do
head=(gene*)testmalloc((size_t)number_of_elements*sizeof(gene));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,114);
return(head);
} /* ; */
chromosome* MACh(long int number_of_elements)
{
chromosome *head;
int i=0;
do
head=(chromosome*)testmalloc((size_t)number_of_elements*sizeof(chromosome));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
learning_algorithm* MALA(long int number_of_elements)
{
learning_algorithm *head;
int i=0;
do
head=(learning_algorithm*)testmalloc((size_t)number_of_elements*sizeof(learning_algorithm));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
neuron_learning_algorithm* MANLA(long int number_of_elements)
{
neuron_learning_algorithm *head;
int i=0;
do
head=(neuron_learning_algorithm*)testmalloc((size_t)number_of_elements*sizeof(neuron_learning_algorithm));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2* MAART2(long int number_of_elements)
{
ART2 *head;
int i=0;
do
head=(ART2*)testmalloc((size_t)number_of_elements*sizeof(ART2));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F1* MAART2_F1(long int number_of_elements)
{
ART2_F1 *head;
int i=0;
do
head=(ART2_F1*)testmalloc((size_t)number_of_elements*sizeof(ART2_F1));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F2* MAART2_F2(long int number_of_elements)
{
ART2_F2 *head;
int i=0;
do
head=(ART2_F2*)testmalloc((size_t)number_of_elements*sizeof(ART2_F2));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
connection* MACn(long int number_of_elements)
{
connection *head;
int i=0;
do
head=(connection*)testmalloc((size_t)number_of_elements*sizeof(connection));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct input_size* MAIS(long int number_of_elements)
{
struct input_size *head;
int i=0;
do
head=(struct input_size*)testmalloc((size_t)number_of_elements*sizeof(struct input_size));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct subsystem_tree* MASST(long int number_of_elements)
{
struct subsystem_tree *head;
int i=0;
do
head=(struct subsystem_tree*)testmalloc((size_t)number_of_elements*sizeof(struct subsystem_tree));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
koef_learn** MApKL(long int number_of_elements)
{
koef_learn **head;
int i=0;
do
head=(koef_learn**)testmalloc((size_t)number_of_elements*sizeof(koef_learn*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,116);
return(head);
} /* ; */
Level** MApLe(long int number_of_elements)
{
Level **head;
int i=0;
do
head=(Level**)testmalloc((size_t)number_of_elements*sizeof(Level*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,117);
return(head);
} /* ; */
neuron** MApN(long int number_of_elements)
{
neuron **head;
int i=0;
do
head=(neuron**)testmalloc((size_t)number_of_elements*sizeof(neuron*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,118);
return(head);
} /* ; */
backwinner** MApBW(long int number_of_elements)
{
backwinner **head;
int i=0;
do
head=(backwinner**)testmalloc((size_t)number_of_elements*sizeof(backwinner*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,119);
return(head);
} /* ; */
p_backwinner** MApPBW(long int number_of_elements)
{
p_backwinner **head;
int i=0;
do
head=(p_backwinner**)testmalloc((size_t)number_of_elements*sizeof(p_backwinner*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,120);
return(head);
} /* ; */
fuzzy_state_neural_network** MApFSNN(long int number_of_elements)
{
fuzzy_state_neural_network **head;
int i=0;
do
head=(fuzzy_state_neural_network**)testmalloc((size_t)number_of_elements*sizeof(fuzzy_state_neural_network*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,121);
return(head);
} /* ; */
BP_correction_memory** MApBPCM(long int number_of_elements)
{
BP_correction_memory **head;
int i=0;
do
head=(BP_correction_memory**)testmalloc((size_t)number_of_elements*sizeof(BP_correction_memory*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,122);
return(head);
} /* ; */
neuron_population** MApNP(long int number_of_elements)
{
neuron_population **head;
int i=0;
do
head=(neuron_population**)testmalloc((size_t)number_of_elements*sizeof(neuron_population*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,123);
return(head);
} /* ; */
neural_subsystem** MApNSS(long int number_of_elements)
{
neural_subsystem **head;
int i=0;
do
head=(neural_subsystem**)testmalloc((size_t)number_of_elements*sizeof(neural_subsystem*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,124);
return(head);
} /* ; */
neural_system** MApNS(long int number_of_elements)
{
neural_system **head;
int i=0;
do
head=(neural_system**)testmalloc((size_t)number_of_elements*sizeof(neural_system*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,125);
return(head);
} /* ; */
neuron_type_descriptor** MApNTD(long int number_of_elements)
{
neuron_type_descriptor **head;
int i=0;
do
head=(neuron_type_descriptor**)testmalloc((size_t)number_of_elements*sizeof(neuron_type_descriptor*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,126);
return(head);
} /* ; */
set_of_neuron_types** MApSNT(long int number_of_elements)
{
set_of_neuron_types **head;
int i=0;
do
head=(set_of_neuron_types**)testmalloc((size_t)number_of_elements*sizeof(set_of_neuron_types*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,127);
return(head);
} /* ; */
nucleotide_base** MApNB(long int number_of_elements)
{
nucleotide_base **head;
int i=0;
do
head=(nucleotide_base**)testmalloc((size_t)number_of_elements*sizeof(nucleotide_base*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,128);
return(head);
} /* ; */
gene** MApG(long int number_of_elements)
{
gene **head;
int i=0;
do
head=(gene**)testmalloc((size_t)number_of_elements*sizeof(gene*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,129);
return(head);
} /* ; */
chromosome** MApCh(long int number_of_elements)
{
chromosome **head;
int i=0;
do
head=(chromosome**)testmalloc((size_t)number_of_elements*sizeof(chromosome*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,130);
return(head);
} /* ; */
learning_algorithm** MApLA(long int number_of_elements)
{
learning_algorithm **head;
int i=0;
do
head=(learning_algorithm**)testmalloc((size_t)number_of_elements*sizeof(learning_algorithm*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
neuron_learning_algorithm** MApNLA(long int number_of_elements)
{
neuron_learning_algorithm **head;
int i=0;
do
head=(neuron_learning_algorithm**)testmalloc((size_t)number_of_elements*sizeof(neuron_learning_algorithm*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2** MApART2(long int number_of_elements)
{
ART2 **head;
int i=0;
do
head=(ART2**)testmalloc((size_t)number_of_elements*sizeof(ART2*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F1** MApART2_F1(long int number_of_elements)
{
ART2_F1 **head;
int i=0;
do
head=(ART2_F1**)testmalloc((size_t)number_of_elements*sizeof(ART2_F1*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F2** MApART2_F2(long int number_of_elements)
{
ART2_F2 **head;
int i=0;
do
head=(ART2_F2**)testmalloc((size_t)number_of_elements*sizeof(ART2_F2*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
connection** MApCn(long int number_of_elements)
{
connection **head;
int i=0;
do
head=(connection**)testmalloc((size_t)number_of_elements*sizeof(connection*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct input_size** MApIS(long int number_of_elements)
{
struct input_size **head;
int i=0;
do
head=(struct input_size**)testmalloc((size_t)number_of_elements*sizeof(struct input_size*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct subsystem_tree** MApSST(long int number_of_elements)
{
struct subsystem_tree **head;
int i=0;
do
head=(struct subsystem_tree**)testmalloc((size_t)number_of_elements*sizeof(struct subsystem_tree*));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
koef_learn*** MAppKL(long int number_of_elements)
{
koef_learn ***head;
int i=0;
do
head=(koef_learn***)testmalloc((size_t)number_of_elements*sizeof(koef_learn**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,131);
return(head);
} /* ; */
Level*** MAppLe(long int number_of_elements)
{
Level ***head;
int i=0;
do
head=(Level***)testmalloc((size_t)number_of_elements*sizeof(Level**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,132);
return(head);
} /* ; */
neuron*** MAppN(long int number_of_elements)
{
neuron ***head;
int i=0;
do
head=(neuron***)testmalloc((size_t)number_of_elements*sizeof(neuron**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,133);
return(head);
} /* ; */
backwinner*** MAppBW(long int number_of_elements)
{
backwinner ***head;
int i=0;
do
head=(backwinner***)testmalloc((size_t)number_of_elements*sizeof(backwinner**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,134);
return(head);
} /* ; */
p_backwinner*** MAppPBW(long int number_of_elements)
{
p_backwinner ***head;
int i=0;
do
head=(p_backwinner***)testmalloc((size_t)number_of_elements*sizeof(p_backwinner**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,135);
return(head);
} /* ; */
fuzzy_state_neural_network*** MAppFSNN(long int number_of_elements)
{
fuzzy_state_neural_network ***head;
int i=0;
do
head=(fuzzy_state_neural_network***)testmalloc((size_t)number_of_elements*sizeof(fuzzy_state_neural_network**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,136);
return(head);
} /* ; */
BP_correction_memory*** MAppBPCM(long int number_of_elements)
{
BP_correction_memory ***head;
int i=0;
do
head=(BP_correction_memory***)testmalloc((size_t)number_of_elements*sizeof(BP_correction_memory**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,137);
return(head);
} /* ; */
neuron_population*** MAppNP(long int number_of_elements)
{
neuron_population ***head;
int i=0;
do
head=(neuron_population***)testmalloc((size_t)number_of_elements*sizeof(neuron_population**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,138);
return(head);
} /* ; */
neural_subsystem*** MAppNSS(long int number_of_elements)
{
neural_subsystem ***head;
int i=0;
do
head=(neural_subsystem***)testmalloc((size_t)number_of_elements*sizeof(neural_subsystem**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,139);
return(head);
} /* ; */
neural_system*** MAppNS(long int number_of_elements)
{
neural_system ***head;
int i=0;
do
head=(neural_system***)testmalloc((size_t)number_of_elements*sizeof(neural_system**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,140);
return(head);
} /* ; */
neuron_type_descriptor*** MAppNTD(long int number_of_elements)
{
neuron_type_descriptor ***head;
int i=0;
do
head=(neuron_type_descriptor***)testmalloc((size_t)number_of_elements*sizeof(neuron_type_descriptor**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,141);
return(head);
} /* ; */
set_of_neuron_types*** MAppSNT(long int number_of_elements)
{
set_of_neuron_types ***head;
int i=0;
do
head=(set_of_neuron_types***)testmalloc((size_t)number_of_elements*sizeof(set_of_neuron_types**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,142);
return(head);
} /* ; */
nucleotide_base*** MAppNB(long int number_of_elements)
{
nucleotide_base ***head;
int i=0;
do
head=(nucleotide_base***)testmalloc((size_t)number_of_elements*sizeof(nucleotide_base**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,143);
return(head);
} /* ; */
gene*** MAppG(long int number_of_elements)
{
gene ***head;
int i=0;
do
head=(gene***)testmalloc((size_t)number_of_elements*sizeof(gene**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,144);
return(head);
} /* ; */
chromosome*** MAppCh(long int number_of_elements)
{
chromosome ***head;
int i=0;
do
head=(chromosome***)testmalloc((size_t)number_of_elements*sizeof(chromosome**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,145);
return(head);
} /* ; */
learning_algorithm*** MAppLA(long int number_of_elements)
{
learning_algorithm ***head;
int i=0;
do
head=(learning_algorithm***)testmalloc((size_t)number_of_elements*sizeof(learning_algorithm**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
neuron_learning_algorithm*** MAppNLA(long int number_of_elements)
{
neuron_learning_algorithm ***head;
int i=0;
do
head=(neuron_learning_algorithm***)testmalloc((size_t)number_of_elements*sizeof(neuron_learning_algorithm**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2*** MAppART2(long int number_of_elements)
{
ART2 ***head;
int i=0;
do
head=(ART2***)testmalloc((size_t)number_of_elements*sizeof(ART2**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F1*** MAppART2_F1(long int number_of_elements)
{
ART2_F1 ***head;
int i=0;
do
head=(ART2_F1***)testmalloc((size_t)number_of_elements*sizeof(ART2_F1**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F2*** MAppART2_F2(long int number_of_elements)
{
ART2_F2 ***head;
int i=0;
do
head=(ART2_F2***)testmalloc((size_t)number_of_elements*sizeof(ART2_F2**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
connection*** MAppCn(long int number_of_elements)
{
connection ***head;
int i=0;
do
head=(connection***)testmalloc((size_t)number_of_elements*sizeof(connection**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct input_size*** MAppIS(long int number_of_elements)
{
struct input_size ***head;
int i=0;
do
head=(struct input_size***)testmalloc((size_t)number_of_elements*sizeof(struct input_size**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct subsystem_tree*** MAppSST(long int number_of_elements)
{
struct subsystem_tree ***head;
int i=0;
do
head=(struct subsystem_tree***)testmalloc((size_t)number_of_elements*sizeof(struct subsystem_tree**));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
koef_learn**** MApppKL(long int number_of_elements)
{
koef_learn ****head;
int i=0;
do
head=(koef_learn****)testmalloc((size_t)number_of_elements*sizeof(koef_learn***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,146);
return(head);
} /* ; */
Level**** MApppLe(long int number_of_elements)
{
Level ****head;
int i=0;
do
head=(Level****)testmalloc((size_t)number_of_elements*sizeof(Level***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,147);
return(head);
} /* ; */
neuron**** MApppN(long int number_of_elements)
{
neuron ****head;
int i=0;
do
head=(neuron****)testmalloc((size_t)number_of_elements*sizeof(neuron***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,148);
return(head);
} /* ; */
backwinner**** MApppBW(long int number_of_elements)
{
backwinner ****head;
int i=0;
do
head=(backwinner****)testmalloc((size_t)number_of_elements*sizeof(backwinner***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,149);
return(head);
} /* ; */
p_backwinner**** MApppPBW(long int number_of_elements)
{
p_backwinner ****head;
int i=0;
do
head=(p_backwinner****)testmalloc((size_t)number_of_elements*sizeof(p_backwinner***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,150);
return(head);
} /* ; */
fuzzy_state_neural_network**** MApppFSNN(long int number_of_elements)
{
fuzzy_state_neural_network ****head;
int i=0;
do
head=(fuzzy_state_neural_network****)testmalloc((size_t)number_of_elements*sizeof(fuzzy_state_neural_network***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,151);
return(head);
} /* ; */
BP_correction_memory**** MApppBPCM(long int number_of_elements)
{
BP_correction_memory ****head;
int i=0;
do
head=(BP_correction_memory****)testmalloc((size_t)number_of_elements*sizeof(BP_correction_memory***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,152);
return(head);
} /* ; */
neuron_population**** MApppNP(long int number_of_elements)
{
neuron_population ****head;
int i=0;
do
head=(neuron_population****)testmalloc((size_t)number_of_elements*sizeof(neuron_population***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,153);
return(head);
} /* ; */
neural_subsystem**** MApppNSS(long int number_of_elements)
{
neural_subsystem ****head;
int i=0;
do
head=(neural_subsystem****)testmalloc((size_t)number_of_elements*sizeof(neural_subsystem***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,154);
return(head);
} /* ; */
neural_system**** MApppNS(long int number_of_elements)
{
neural_system ****head;
int i=0;
do
head=(neural_system****)testmalloc((size_t)number_of_elements*sizeof(neural_system***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,155);
return(head);
} /* ; */
neuron_type_descriptor**** MApppNTD(long int number_of_elements)
{
neuron_type_descriptor ****head;
int i=0;
do
head=(neuron_type_descriptor****)testmalloc((size_t)number_of_elements*sizeof(neuron_type_descriptor***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,156);
return(head);
} /* ; */
set_of_neuron_types**** MApppSNT(long int number_of_elements)
{
set_of_neuron_types ****head;
int i=0;
do
head=(set_of_neuron_types****)testmalloc((size_t)number_of_elements*sizeof(set_of_neuron_types***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,157);
return(head);
} /* ; */
nucleotide_base**** MApppNB(long int number_of_elements)
{
nucleotide_base ****head;
int i=0;
do
head=(nucleotide_base****)testmalloc((size_t)number_of_elements*sizeof(nucleotide_base***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,158);
return(head);
} /* ; */
gene**** MApppG(long int number_of_elements)
{
gene ****head;
int i=0;
do
head=(gene****)testmalloc((size_t)number_of_elements*sizeof(gene***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,159);
return(head);
} /* ; */
chromosome**** MApppCh(long int number_of_elements)
{
chromosome ****head;
int i=0;
do
head=(chromosome****)testmalloc((size_t)number_of_elements*sizeof(chromosome***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,160);
return(head);
} /* ; */
learning_algorithm**** MApppLA(long int number_of_elements)
{
learning_algorithm ****head;
int i=0;
do
head=(learning_algorithm****)testmalloc((size_t)number_of_elements*sizeof(learning_algorithm***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
neuron_learning_algorithm**** MApppNLA(long int number_of_elements)
{
neuron_learning_algorithm ****head;
int i=0;
do
head=(neuron_learning_algorithm****)testmalloc((size_t)number_of_elements*sizeof(neuron_learning_algorithm***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2**** MApppART2(long int number_of_elements)
{
ART2 ****head;
int i=0;
do
head=(ART2****)testmalloc((size_t)number_of_elements*sizeof(ART2***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F1**** MApppART2_F1(long int number_of_elements)
{
ART2_F1 ****head;
int i=0;
do
head=(ART2_F1****)testmalloc((size_t)number_of_elements*sizeof(ART2_F1***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
ART2_F2**** MApppART2_F2(long int number_of_elements)
{
ART2_F2 ****head;
int i=0;
do
head=(ART2_F2****)testmalloc((size_t)number_of_elements*sizeof(ART2_F2***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
connection**** MApppCn(long int number_of_elements)
{
connection ****head;
int i=0;
do
head=(connection****)testmalloc((size_t)number_of_elements*sizeof(connection***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct input_size**** MApppIS(long int number_of_elements)
{
struct input_size ****head;
int i=0;
do
head=(struct input_size****)testmalloc((size_t)number_of_elements*sizeof(struct input_size***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
struct subsystem_tree**** MApppSST(long int number_of_elements)
{
struct subsystem_tree ****head;
int i=0;
do
head=(struct subsystem_tree****)testmalloc((size_t)number_of_elements*sizeof(struct subsystem_tree***));
while((head==0)&&(++i<101));
if((number_of_elements>0)&&(head==0)) exit_handling(1,115);
return(head);
} /* ; */
/* *fill_node() puni ~vor inicijalnim te`inama i pointerima na prethodni sloj (odnosno izvoru pobude) pomo}u funkcije *fill_weight() koja puni te`ine i pointere */
characteristic *fill_weight(characteristic *link, float *weights)
{ characteristic *head;
head=MACl((long int)1);
head->name=MAC((long int)2);
*(head->name+0)='w';
*(head->name+1)=' ';
head->membership= *weights;
head->ahead=link;
head->follow=0;
return(head);
}/* ; */
fuzzy_object *fill_node(int nmbr_weights, float *weights)
{ int counter;
fuzzy_object*head;
head=MAFO((long int)1);
head->actual=0;
head->number_of_characteristics=nmbr_weights;
head->first=fill_weight(head->actual, weights++);
head->actual=head->first;
for(counter=1; counternumber_of_characteristics; counter++)
{ head->last=fill_weight(head->actual,weights++);
head->actual->follow=head->last;
head->actual=head->last;
};
return(head);
}/* ; */
/* *fill_Level() puni svaki sloj s te`inama iz weights vektora */
Level *fill_Level(int Level_Nr, int nmbr_of_weights, int nmbr_of_nodes, float *weights, Level *ahead)
{ int counter;
Level *head;
head=MALe((long int)1);
head->nodes=MApFO((long int)(unsigned)nmbr_of_nodes);
head->Level_number=Level_Nr;
head->number_of_nodes=nmbr_of_nodes;
head->ahead=ahead;
for(counter=0; counternumber_of_nodes; counter++)
{ (*(head->nodes+counter))=fill_node(nmbr_of_weights,weights);
weights+=nmbr_of_weights;
};
head->follow=0;
return(head);
}/* ; */
/* net_output() pohranjuje izlaz iz mre`e u fuzzy skup s zadanim imenom i imenima klasa, a pointer *set svake klase ukazuje na njen ulaz; tako|er upisuje pointer na izlaz u neuron.output */
fuzzy_object*net_output(neuron *net_head, char *names)
{
fuzzy_object*head;
float *memberships;
int br;
memberships=MAF((long int)(int)net_head->last_Level->number_of_nodes);
for(br=0; brlast_Level->number_of_nodes; *(memberships+(br++))=0.0);
head=set_fill(net_head->last_Level->number_of_nodes, names, memberships);
testfree((char*)memberships);
for(head->actual=head->first, br=0; head->actual!=0; head->actual=head->actual->follow, br++)
head->actual->set= *(net_head->last_Level->nodes+br);
net_head->output=head;
return(head);
}/* ; */
/* fill_net() upravlja generiranjem mre`e na osnovu zadanih: *name, *nmbr_of_nodes, nmbr_of_net_input, *weights, *input */
neuron *fill_net(char *name, int nmbr_of_Levels, int *nmbr_of_nodes, int nmbr_of_net_input, char* output_names, float *weights, float *input)
{
neuron *head;
int counter=1, counter1, counter2;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level(counter, nmbr_of_net_input, *nmbr_of_nodes, weights, head->actual_Level);
head->actual_Level=head->first_Level;
for(counter1=0; counter1<*nmbr_of_nodes; counter1++)
for(counter2=0, (*(head->actual_Level->nodes+counter1))->actual=(*(head->actual_Level->nodes+counter1))->first; (counter2actual_Level->nodes+counter1))->actual!=0); counter2++, (*(head->actual_Level->nodes+counter1))->actual=(*(head->actual_Level->nodes+counter1))->actual->follow, input++)
(*(head->actual_Level->nodes+counter1))->actual->set=(link_set)input;
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
return(head);
}/* ; */
/* *fill_net_auto() sama generira: *number_of_nodes, *weights, *output_names */
neuron *fill_net_auto( char *name, int number_of_Levels, int nmbr_of_net_input, int number_of_net_output, float *input)
{
int counter, c1=0, counter1, counter2, *number_of_nodes;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)(int)number_of_Levels);
for(counter=1, counter2=(int)(nmbr_of_net_input*(nmbr_of_net_input+(int)((((float)1/number_of_Levels)*((int)number_of_net_output-(int)nmbr_of_net_input))))); counter0) ? (float)1.0/(*(number_of_nodes+counter-1)) : (float)1.0/nmbr_of_net_input;
if ((int)(counter)>0)
for(counter1=0; counter1<((*(number_of_nodes+(counter-1)))*(*(number_of_nodes+counter))); counter1++)
(*(weights+(c1++)))=mem;
else
for(counter1=0; counter1<(nmbr_of_net_input*(*(number_of_nodes))); counter1++)
*(weights+(c1++))=mem;
};
return(fill_net(name, number_of_Levels, number_of_nodes, nmbr_of_net_input, output_names, weights, input));
}/* ; */
/* *fill_net_auto_defLev() je kao *fill_net_auto() samo sto korisnik sljedno definira broj cvorova po slojevima, osim prvog i posljednjeg sloja */
neuron *fill_net_auto_defLev( char *name, int number_of_Levels, int nmbr_of_net_input, int number_of_net_output, float *input, int *nr_of_nodes)
{
int counter, c1=0, counter1, counter2, *number_of_nodes;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)(int)number_of_Levels);
counter2=nmbr_of_net_input+number_of_net_output*(*(nr_of_nodes+number_of_Levels-3));
for(counter=0; counter<(int)(number_of_Levels)-2;counter++)
counter2+=(counter>0)?(*(nr_of_nodes+counter-1))*(*(nr_of_nodes+counter)):(*(nr_of_nodes+counter))*nmbr_of_net_input;
weights=MAF((long int)counter2);
output_names=MAC((long int)(unsigned)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counter0) ? (float)1.0/(*(number_of_nodes+counter-1)) : (float)1.0/nmbr_of_net_input;
if ((int)(counter)>0)
for(counter1=0; counter1<((*(number_of_nodes+(counter-1)))*(*(number_of_nodes+counter))); counter1++)
(*(weights+(c1++)))=mem;
else
for(counter1=0; counter1<(nmbr_of_net_input*(*(number_of_nodes))); counter1++)
*(weights+(c1++))=mem;
};
return(fill_net(name, number_of_Levels, number_of_nodes, nmbr_of_net_input, output_names, weights, input));
}/* ; */
/* *fill_Level1_overlaping() ista je kao *fill_Level(), samo sto je ulaz u cvor pripadni pixel i njegova overlap okolina, te samo puni cvorove prvog sloja */
Level *fill_Level1_overlaping(int number_of_nodes, float *input, int overlap, int dimension1, int dimension2)
{
int c1, c2, cel, co1, co1d, co1u, co2, co2d, co2u, coel;
Level *head;
head=MALe((long int)1);
head->number_of_nodes=number_of_nodes;
head->nodes=MApFO((long int)(int)head->number_of_nodes);
head->Level_number=1;
head->ahead=0;
head->follow=0;
for(c1=0; c1nodes+cel)=MAFO((long int)1);
coel=cel;
(*(head->nodes+cel))->last=MACl((long int)1);
(*(head->nodes+cel))->first=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->ahead=0;
(*(head->nodes+cel))->last->name=MAC((long int)1);
(*(head->nodes+cel))->last->membership=1.0;
(*(head->nodes+cel))->actual=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->follow=0;
(*(head->nodes+cel))->last->set=(fuzzy_object*)(input+coel);
co1d=(c1>(int)(overlap)-1)? c1-overlap: 0;
co1u=((int)(overlap)<(int)(dimension1)-c1)? c1+overlap: dimension1;
co2d=((int)(c2)>(int)(overlap)-1)? c2-overlap: 0;
co2u=((int)(overlap)<(int)(dimension2)-c2)? c2+overlap: dimension2;
for(co1=co1d; co1nodes+cel))->last=MACl((long int)1);
(*(head->nodes+cel))->last->ahead=(*(head->nodes+cel))->actual;
(*(head->nodes+cel))->actual->follow=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->name=MAC((long int)1);
(*(head->nodes+cel))->last->membership=1.0;
(*(head->nodes+cel))->actual=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->follow=0;
(*(head->nodes+cel))->last->set=(fuzzy_object*)(input+coel);
};
fuzzy_object_normalisation(*(head->nodes+cel));
};
return(head);
} /* ; */
/* fill_net_overlaping() ista je kao *fill_net(), samo sto je ulaz u cvor pripadni pixel i njegova overlap okolina */
neuron *fill_net_overlaping(char *name, int nmbr_of_Levels, int *nmbr_of_nodes, int nmbr_of_net_input, char* output_names, float *weights, float *input, int overlap, int dimension1, int dimension2)
{
neuron *head;
int counter=1, counter1, counter2;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level1_overlaping(nmbr_of_net_input, input, overlap, dimension1, dimension2);
head->actual_Level=head->first_Level;
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
return(head);
}/* ; */
/* *fill_net_auto_overlaping() ista je kao *fill_net_auto(), samo sto je ulaz u cvor pripadni pixel i njegova overlap okolina */
neuron *fill_net_auto_overlaping( char *name, int number_of_Levels, int number_of_net_output, float *input, int overlap, int dimension1, int dimension2)
{
int counter, c1=0, counter1, counter2, *number_of_nodes, nmbr_of_net_input=dimension1 * dimension2;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)(int)number_of_Levels);
for(counter=1, counter2=(int)(nmbr_of_net_input*(nmbr_of_net_input+(int)((((float)1/number_of_Levels)*((int)number_of_net_output-(int)nmbr_of_net_input))))); counter0) ? (float)1.0/(*(number_of_nodes+counter-1)) : (float)1.0/nmbr_of_net_input;
if ((int)(counter)>0)
for(counter1=0; counter1<((*(number_of_nodes+(counter-1)))*(*(number_of_nodes+counter))); counter1++)
(*(weights+(c1++)))=mem;
else
for(counter1=0; counter1<(nmbr_of_net_input*(*(number_of_nodes))); counter1++)
*(weights+(c1++))=mem;
};
return(fill_net_overlaping(name, number_of_Levels, number_of_nodes, nmbr_of_net_input, output_names, weights, input, overlap, dimension1, dimension2));
}/* ; */
/* *fill_net_auto_defLev_overlaping() ista je kao *fill_net_auto_defLev(), samo sto je ulaz u cvor pripadni pixel i njegova overlap okolina */
neuron *fill_net_auto_defLev_overlaping( char *name, int number_of_Levels, int number_of_net_output, float *input, int *nr_of_nodes, int overlap, int dimension1, int dimension2)
{
int counter, c1=0, counter1, counter2, *number_of_nodes, nmbr_of_net_input=dimension1 * dimension2;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)(int)number_of_Levels);
counter2=nmbr_of_net_input+number_of_net_output*(*(nr_of_nodes+number_of_Levels-3));
for(counter=0; counter<(int)(number_of_Levels)-2;counter++)
counter2+=((int)(counter)>0)?(*(nr_of_nodes+counter-1))*(*(nr_of_nodes+counter)):(*(nr_of_nodes+counter))*nmbr_of_net_input;
weights=MAF((long int)counter2);
output_names=MAC((long int)(unsigned)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counter0) ? (float)1.0/(*(number_of_nodes+counter-1)) : (float)1.0/nmbr_of_net_input;
if ((int)(counter)>0)
for(counter1=0; counter1<((*(number_of_nodes+(counter-1)))*(*(number_of_nodes+counter))); counter1++)
(*(weights+(c1++)))=mem;
else
for(counter1=0; counter1<(nmbr_of_net_input*(*(number_of_nodes))); counter1++)
*(weights+(c1++))=mem;
};
return(fill_net_overlaping(name, number_of_Levels, number_of_nodes, nmbr_of_net_input, output_names, weights, input, overlap, dimension1, dimension2));
}/* ; */
/* *fill_weight_for_fuzzy_input() puni te`ine ~vorova za fuzzy ulaz tako da svaka te`ina odgovara jednoj klasi ulaznog fuzzy skupa */
characteristic *fill_weight_for_fuzzy_input(characteristic *link, float weight)
{
characteristic *head;
head=MACl((long int)1);
head->name=MAC((long int)20);
head->membership=weight;
head->ahead=link;
head->follow=0;
return(head);
}/* ; */
/* *fill_node_for_fuzzy_input() puni ~vor prvog sloja kod fuzzy ulaza tako da svaki ~vor odgovara pripadnom fuzzy skupu na ulazu */
fuzzy_object*fill_node_for_fuzzy_input(fuzzy_object*fuzzy_input)
{
float weight;
int counter;
fuzzy_object*head;
head=MAFO((long int)1);
head->actual=0;
for(fuzzy_input->actual=fuzzy_input->first, head->number_of_characteristics=0; fuzzy_input->actual!=0; fuzzy_input->actual=fuzzy_input->actual->follow)
head->number_of_characteristics++;
weight=(float)1.0/head->number_of_characteristics;
head->first=fill_weight_for_fuzzy_input(head->actual, weight);
head->actual=head->first;
head->actual->follow=0;
for(counter=1; counternumber_of_characteristics; counter++)
{ head->last=fill_weight_for_fuzzy_input(head->actual, weight);
head->actual->follow=head->last;
head->actual=head->last;
};
return(head);
}/* ; */
/* *fill_Level1_fuzzy_input() sli~na je funkciji *fill_Level() samo {to vodi ra~una da je to prvi sloj s fuzzy ulazom u kojem je mogu}e da se za svaki ~vor postavlja razli~iti broj te`ina */
Level *fill_Level1_fuzzy_input(int Level_No, int number_of_nodes, link_set *fuzzy_input, Level *ahead)
{
int counter;
Level *head;
head=MALe((long int)1);
head->nodes=MApFO((long int)number_of_nodes);
head->Level_number=Level_No;
head->number_of_nodes=number_of_nodes;
head->ahead=ahead;
for(counter=0; counternumber_of_nodes; counter++)
(*(head->nodes+counter))=fill_node_for_fuzzy_input(*(fuzzy_input+counter));
head->follow=0;
return(head);
}/* ; */
/* *fill_net_fuzzy_input() ista je kao *fill_net() samo {to je ulaz u mre`u skup fuzzy skupova, *weights ne sadr`i te`ine prvog sluja mre`e, (*(number_of_nodes+0)) mora biti jednak broju fuzzy skupova na ulazu */
neuron *fill_net_fuzzy_input(char *name, int nmbr_of_Levels, int *nmbr_of_nodes, char* output_names, float *weights, link_set *fuzzy_input)
{
neuron *head;
int counter=1, counter1, counter2, nmbr_of_net_input= *nmbr_of_nodes;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level1_fuzzy_input(counter, nmbr_of_net_input, fuzzy_input, head->actual_Level);
head->actual_Level=head->first_Level;
for(counter1=0; counter1<*nmbr_of_nodes; counter1++)
for((*(fuzzy_input+counter1))->actual=(*(fuzzy_input+counter1))->first, (*(head->actual_Level->nodes+counter1))->actual=(*(head->actual_Level->nodes+counter1))->first; (*(fuzzy_input+counter1))->actual!=0; (*(fuzzy_input+counter1))->actual=(*(fuzzy_input+counter1))->actual->follow, (*(head->actual_Level->nodes+counter1))->actual=(*(head->actual_Level->nodes+counter1))->actual->follow)
(*(head->actual_Level->nodes+counter1))->actual->set=(fuzzy_object*)(&((*(fuzzy_input+counter1))->actual->membership));
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
return(head);
}/* ; */
/* *fill_net_auto_fuzzy_input() je ista kao *fill_net_auto() samo {to je ulaz u mre`u skup fuzzy skupova */
neuron *fill_net_auto_fuzzy_input( char *name, int number_of_Levels, int nmbr_of_fuzzy_objects_for_input, int number_of_net_output, fuzzy_object* *fuzzy_input)
{
int counter, c1, counter1, counter2, *number_of_nodes;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)number_of_Levels);
*number_of_nodes=nmbr_of_fuzzy_objects_for_input;
for(counter=1, counter2=0 ; counter0)?(*(nr_of_nodes+counter-1))*(*(nr_of_nodes+counter)):(*(nr_of_nodes+counter))*nmbr_of_fuzzy_objects_for_input;
weights=MAF((long int)counter2);
output_names=MAC((long int)(unsigned)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counternumber_of_nodes=number_of_nodes;
head->nodes=MApFO((long int)(int) head->number_of_nodes);
head->Level_number=1;
head->ahead=0;
head->follow=0;
for(c1=0; c1nodes+cel)=MAFO((long int)1);
co1d=((int)(c1)>(int)(overlap)-1)? c1-overlap: 0;
co1u=((int)(overlap)<(int)(dimension1)-c1)? c1+overlap: dimension1;
co2d=((int)(c2)>(int)(overlap)-1)? c2-overlap: 0;
co2u=((int)(overlap)<(int)(dimension2)-c2)? c2+overlap: dimension2;
for(co1=co1d; co1actual=(*(fuzzy_input+coel))->first; (*(fuzzy_input+coel))->actual!=0; (*(fuzzy_input+coel))->actual=(*(fuzzy_input+coel))->actual->follow)
{
(*(head->nodes+cel))->last=MACl((long int)1);
if((co1==co1d)&&(co2==co2d))
{
(*(head->nodes+cel))->first=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->ahead=0;
}
else
{
(*(head->nodes+cel))->last->ahead=(*(head->nodes+cel))->actual;
(*(head->nodes+cel))->actual->follow=(*(head->nodes+cel))->last;
};
(*(head->nodes+cel))->last->name=MAC((long int)1);
(*(head->nodes+cel))->last->membership=1.0;
(*(head->nodes+cel))->actual=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->follow=0;
(*(head->nodes+cel))->last->set=(fuzzy_object*)(&((*(fuzzy_input+coel))->actual->membership));
};
};
fuzzy_object_normalisation(*(head->nodes+cel));
};
return(head);
} /* ; */
/* *fill_net_fuzzy_input_overlaping() ista je kao *fill_net_fuzzy_input() samo {to je ulaz u cvor prvog sloja pripadni pixel i njegova overlap okolina */
neuron *fill_net_fuzzy_input_overlaping(char *name, int nmbr_of_Levels, int *nmbr_of_nodes, char* output_names, float *weights, link_set *fuzzy_input, int overlap, int dimension1, int dimension2)
{
neuron *head;
int counter=1, counter1, counter2, nmbr_of_net_input= *nmbr_of_nodes;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level1_fuzzy_input_overlaping(nmbr_of_net_input, fuzzy_input, overlap, dimension1, dimension2);
head->actual_Level=head->first_Level;
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
return(head);
}/* ; */
/* *fill_net_auto_fuzzy_input_overlaping() je ista kao *fill_net_auto_fuzzy_input() samo {to je ulaz u cvor prvog sloja pripadni pixel i njegova overlap okolina */
neuron *fill_net_auto_fuzzy_input_overlaping( char *name, int number_of_Levels, int number_of_net_output, fuzzy_object* *fuzzy_input, int overlap, int dimension1, int dimension2)
{
int counter, c1, counter1, counter2, *number_of_nodes;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)number_of_Levels);
*number_of_nodes=dimension1* dimension2;
for(counter=1, counter2=0 ; counter0)?(*(nr_of_nodes+counter-1))*(*(nr_of_nodes+counter)):(*(nr_of_nodes+counter))*(*number_of_nodes);
weights=MAF((long int)counter2);
output_names=MAC((long int)(unsigned)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counternodes+counter)=MAFO((long int)1);
for(counter=0; counternodes+counter))->number_of_characteristics=nmbr_of_0weights;
for(counter=0; counteractual=(*(fuzzy_input+counter))->first;
weight=(float)1./nmbr_of_0weights;
for(counter=0; counternodes+0))->last=MACl((long int)1);
(*(head->nodes+0))->last->name=MAC((long int)20);
(*(head->nodes+0))->last->membership=weight;
if ((int)(counter) > 0)
{ (*(head->nodes+0))->last->ahead=(*(head->nodes+0))->actual;
(*(head->nodes+0))->actual->follow=(*(head->nodes+0))->last;
}
else
{ (*(head->nodes+0))->first=(*(head->nodes+0))->last;
(*(head->nodes+0))->last->ahead=0;
};
(*(head->nodes+0))->last->follow=0;
(*(head->nodes+0))->actual=(*(head->nodes+0))->last;
(*(head->nodes+0))->last->set=(fuzzy_object*)(&((*(fuzzy_input+counter))->actual->membership));
};
c1=1;
do
{ for(counter=0; counteractual=(*(fuzzy_input+counter))->actual->follow;
(*(head->nodes+c1))->last=MACl((long int)1);
(*(head->nodes+c1))->last->name=MAC((long int)20);
(*(head->nodes+c1))->last->membership=weight;
(*(head->nodes+c1))->last->follow=0;
if((int)(counter)>0)
{ (*(head->nodes+c1))->last->ahead=(*(head->nodes+c1))->actual;
(*(head->nodes+c1))->actual->follow=(*(head->nodes+c1))->last;}
else
{ (*(head->nodes+c1))->last->ahead=0;
(*(head->nodes+c1))->first= (*(head->nodes+c1))->last; };
(*(head->nodes+c1))->last->set=(fuzzy_object*)(&((*(fuzzy_input+counter))->actual->membership));
(*(head->nodes+c1))->actual=(*(head->nodes+c1))->last;
};
c1++;
} while((int)(c1)nodes=MApFO((long int)number_of_nodes);
head->Level_number=Level_No;
head->number_of_nodes=number_of_nodes;
head->ahead=ahead;
fill_nodes_for_fuzzy_input_characteristic2node(head,fuzzy_input,number_of_nodes, nmbr_of_0weights);
head->follow=0;
return(head);
}/* ; */
/* *fill_net_fuzzy_input_characteristic2node() ista je kao *fill_net_fuzzy_input() samo {to se ~vorovima prvog sloja mre`e pridru`uju istovrsne osobine fuzzy skupovana ulazu. Nu`an uvjet je da su fuzzy skupovi na ulazu identi~ne gra|e - da su osobine (klase) poredane unutar fuzzy skupa (liste) s identi~nim redoslijedom. Parametar nmbr_of_0weights odgovara broju osobina (klasa) svakog ulaznog fuzzy skupa */
neuron *fill_net_fuzzy_input_characteristic2node(char *name, int nmbr_of_Levels, int *nmbr_of_nodes, char* output_names, float *weights, link_set *fuzzy_input, int nmbr_of_0weights)
{
neuron *head;
int counter=1, counter1, counter2, nmbr_of_net_input= *nmbr_of_nodes;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level1_fuzzy_input_characteristic2node(counter, nmbr_of_net_input, fuzzy_input, head->actual_Level, nmbr_of_0weights);
head->actual_Level=head->first_Level;
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
return(head);
}/* ; */
/* *fill_net_auto_fuzzy_input_characteristic2node() ista je kao *fill_net_auto_fuzzy_input() samo {to se ~vorovima prvog sloja mre`e pridru`uju istovrsne osobine fuzzy skupovana ulazu. Nu`an uvjet je da su fuzzy skupovi na ulazu identi~ne gra|e - da su osobine (klase) poredane unutar fuzzy skupa (liste) s identi~nim redoslijedom */
neuron *fill_net_auto_fuzzy_input_characteristic2node( char *name, int number_of_Levels, int nmbr_of_fuzzy_objects_for_input, int number_of_net_output, fuzzy_object* *fuzzy_input)
{
int counter, c1, counter1, counter2, *number_of_nodes, nmbr_of_0weights;
char *output_names;
float mem, *weights;
nmbr_of_0weights=nmbr_of_fuzzy_objects_for_input;
number_of_nodes=MAI((long int)number_of_Levels);
for((*fuzzy_input)->actual=(*fuzzy_input)->first, *number_of_nodes=0; (*fuzzy_input)->actual!=0; (*fuzzy_input)->actual=(*fuzzy_input)->actual->follow)
(*number_of_nodes)++;
for(counter=1, counter2=0 ; counteractual=(*fuzzy_input)->first, *number_of_nodes=0; (*fuzzy_input)->actual!=0; (*fuzzy_input)->actual=(*fuzzy_input)->actual->follow)
(*number_of_nodes)++;
counter2=number_of_net_output*(*(nr_of_nodes+number_of_Levels-3));
for(counter=0; counter<(int)(number_of_Levels)-2;counter++)
counter2+=((int)(counter)>0)?(*(nr_of_nodes+counter-1))*(*(nr_of_nodes+counter)):(*(nr_of_nodes+counter))*nmbr_of_fuzzy_objects_for_input;
weights=MAF((long int)counter2);
output_names=MAC((long int)(int)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counternumber_of_nodes=number_of_nodes;
head->nodes=MApFO((long int)(int) head->number_of_nodes);
head->Level_number=1;
head->ahead=0;
head->follow=0;
for(c1=0, cel=0; c1first; act_characteristic!=0; act_characteristic=act_characteristic->follow)
{
*(head->nodes+cel)=MAFO((long int)1);
coel=c1*dimension2+c2;
(*(fuzzy_input+coel))->actual=(act_characteristic==(*fuzzy_input)->first)?(*(fuzzy_input+coel))->first: (*(fuzzy_input+coel))->actual->follow;
(*(head->nodes+cel))->last=MACl((long int)1);
(*(head->nodes+cel))->first=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->ahead=0;
(*(head->nodes+cel))->last->name=MAC((long int)1);
(*(head->nodes+cel))->last->membership=1.0;
(*(head->nodes+cel))->actual=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->follow=0;
(*(head->nodes+cel))->last->set=(fuzzy_object*)(&((*(fuzzy_input+coel))->actual->membership));
co1d=((int)(c1)>(int)(overlap)-1)? c1-overlap: 0;
co1u=((int)(overlap)<(int)(dimension1)-c1)? c1+overlap: dimension1;
co2d=((int)(c2)>(int)(overlap)-1)? c2-overlap: 0;
co2u=((int)(overlap)<(int)(dimension2)-c2)? c2+overlap: dimension2;
for(co1=co1d; co1actual=(act_characteristic==(*fuzzy_input)->first)?(*(fuzzy_input+coel))->first: (*(fuzzy_input+coel))->actual->follow;
(*(head->nodes+cel))->last=MACl((long int)1);
(*(head->nodes+cel))->last->ahead=(*(head->nodes+cel))->actual;
(*(head->nodes+cel))->actual->follow=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->name=MAC((long int)1);
(*(head->nodes+cel))->last->membership=1.0;
(*(head->nodes+cel))->actual=(*(head->nodes+cel))->last;
(*(head->nodes+cel))->last->follow=0;
(*(head->nodes+cel))->last->set=(fuzzy_object*)(&((*(fuzzy_input+coel))->actual->membership));
};
fuzzy_object_normalisation(*(head->nodes+cel++));
};
};
return(head);
} /* ; */
/* *fill_net_fuzzy_input_characteristic2node_overlaping() ista je kao *fill_net_fuzzy_input_characteristic2node() samo {to su ulaz u cvor istovrsne klase pripadnog pixela i njegove overlap okoline */
neuron *fill_net_fuzzy_input_characteristic2node_overlaping(char *name, int nmbr_of_Levels, int *nmbr_of_nodes, char* output_names, float *weights, link_set *fuzzy_input, int overlap, int dimension1, int dimension2)
{
neuron *head;
int counter=1, counter1, counter2;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level1_fuzzy_input_characteristic2node_overlaping(*nmbr_of_nodes, fuzzy_input, overlap, dimension1, dimension2);
head->actual_Level=head->first_Level;
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
return(head);
}/* ; */
/* *fill_net_auto_fuzzy_input_characteristic2node_overlaping() ista je kao *fill_net_auto_fuzzy_input_characteristic2node() samo {to su ulaz u cvor istovrsne klase pripadnog pixela i njegove overlap okoline */
neuron *fill_net_auto_fuzzy_input_characteristic2node_overlaping( char *name, int number_of_Levels, int number_of_net_output, fuzzy_object* *fuzzy_input, int overlap, int dimension1, int dimension2)
{
int counter, c1, counter1, counter2, *number_of_nodes;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)number_of_Levels);
for((*fuzzy_input)->actual=(*fuzzy_input)->first, *number_of_nodes=0; (*fuzzy_input)->actual!=0; (*fuzzy_input)->actual=(*fuzzy_input)->actual->follow)
(*number_of_nodes)++;
(*number_of_nodes)*=dimension1 * dimension2;
for(counter=1, counter2=0 ; counteractual=(*fuzzy_input)->first, *number_of_nodes=0; (*fuzzy_input)->actual!=0; (*fuzzy_input)->actual=(*fuzzy_input)->actual->follow)
(*number_of_nodes)++;
(*number_of_nodes)*=dimension1 * dimension2;
counter2=number_of_net_output*(*(nr_of_nodes+number_of_Levels-3));
for(counter=0; counter<(int)(number_of_Levels)-2;counter++)
counter2+=((int)(counter)>0)?(*(nr_of_nodes+counter-1))*(*(nr_of_nodes+counter)):(*(nr_of_nodes+counter))*(*number_of_nodes);
weights=MAF((long int)counter2);
output_names=MAC((long int)(unsigned)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counterfirst;
while(new_characteristic != 0)
{ act_characteristic=new_characteristic;
new_characteristic=act_characteristic->follow;
if(act_characteristic->name!=0) testfree((char*) act_characteristic->name);
testfree((char*) act_characteristic);
};
testfree((char*) head);
}/* ; */
/* delete_Level() je funkcija za brisanje sloja pohranjene mre`e kod brisanja mre`e. U slu}aju kada se iz mre`e `eli samo izbaciti neki sloj, treba taj sloj prije brisanja premostiti (preusmjeriti pointere te`ina slijede}eg sloja)! */
void delete_Level(Level *head)
{
int counter;
for(counter=0; counter < head->number_of_nodes; counter++)
delete_node((*(head->nodes+counter)));
testfree((char*)(float*)head->nodes);
testfree((char*)head);
}/* ; */
/* delete_neuron() je funkcija za brisanje pohranjene mre`e */
void delete_neuron(neuron *head)
{ for(head->actual_Level=head->first_Level; head->actual_Level!=head->last_Level; head->actual_Level=head->actual_Level->follow)
delete_Level(head->actual_Level);
delete_Level(head->last_Level);
delete_node(head->output);
if(head->name!=0) testfree((char*) head->name);
testfree((char*) head);
}/* ; */
/* *construct_backwinner() konstruira niz s elementima tipa backwinner i pointerom na njen po~etak i kraj tipa p_backwinner */
p_backwinner *construct_backwinner(neuron *net_head)
{
int counter;
p_backwinner *p_head;
backwinner *head, *head_ahead;
p_head=MAPBW((long int)1);
head=MABW((long int)1);
head->ahead=0;
head->follow=0;
p_head->first=head;
for(counter=1; counternumber_of_Levels; counter++)
{
head_ahead=head;
head=MABW((long int)1);
head_ahead->follow=head;
head->ahead=head_ahead;
head->follow=0;
};
p_head->last=head;
return(p_head);
}/* ; */
/* fill_backwinner() puni listu pointerima na klase (te`ine) preko kojih je propagirala najve}a pobuda s ulaza na izlaz mre`e */
void fill_backwinner(p_backwinner *head, neuron *net_head)
{
backwinner *actual;
head->last->winner=net_head->output->actual->set;
head->last->weight=head->last->winner->actual;
actual=head->last->ahead;
while(actual)
{ actual->winner=actual->follow->weight->set;
actual->weight=actual->winner->actual;
actual=actual->ahead;
};
}/* ; */
/* treasurehold_set() enable setting of treasurehold level */
void treasurehold_set(float new_value)
{
extern float treasureholdadd;
treasureholdadd=new_value;
} /* ; */
/* node_output_e_exponent_set() enable setting of node_output_e_exponent value */
void node_output_e_exponent_set(float new_value)
{
extern float node_output_e_exponent;
node_output_e_exponent=new_value;
} /* ; */
/* node_out_type() define type of node output */
void node_out_type( char t)
{
extern char node_output_type;
node_output_type=t;
} /* ; */
/* node_output() omogu}ava nelinearizaciju izlaza iz ~vora i postavljanje praga osjeta, ovisno o sloju u kojem se ~vor nalazi */
float node_output(float value)
{
extern float treasureholdadd, node_output_e_exponent;
extern char node_output_type;
float noutput, treasurehold ;
treasurehold = (float)0.0 + treasureholdadd;
if(value1.0) noutput=1.0; */
return(noutput);
}/* ; */
/* cycle() izvr{ava jedan ciklus rada mre`e */
void cycle(neuron *net_head)
{
characteristic *act_characteristic;
int br;
float sum;
net_head->actual_Level=net_head->first_Level;
sum=0.0;
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
(*(net_head->actual_Level->nodes+br))->actual=(*(net_head->actual_Level->nodes+br))->first;
do
{ (*(net_head->actual_Level->nodes+br))->m.notes+=(*((float*)(act_characteristic->set)))*act_characteristic->membership;
if((*((float*)((*(net_head->actual_Level->nodes+br))->actual->set))) < ((*((float*)(act_characteristic->set)))))
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->m.notes);
sum+=(*(net_head->actual_Level->nodes+br))->m.notes;
};
if(sum<0.01)
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes+=(float)1./net_head->actual_Level->number_of_nodes;
else
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes*=1/sum;
net_head->actual_Level=net_head->actual_Level->follow;
do
{ sum=0.0;
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
do
{ (*(net_head->actual_Level->nodes+br))->m.notes += (act_characteristic->set->m.notes * act_characteristic->membership);
if((*(net_head->actual_Level->nodes+br))->actual->set->m.notesset->m.notes)
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
if(net_head->actual_Level->follow!=0)
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->m.notes);
sum+=(*(net_head->actual_Level->nodes+br))->m.notes;
};
if(sum<0.01)
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes+=(float)1.0/net_head->actual_Level->number_of_nodes;
else
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes*=1/sum;
net_head->actual_Level=net_head->actual_Level->follow;
} while(net_head->actual_Level!=0);
act_characteristic=net_head->output->first;
net_head->output->actual=act_characteristic;
do
{ act_characteristic->membership=act_characteristic->set->m.notes;
if(net_head->output->actual->set->m.notesmembership)
net_head->output->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
fuzzy_object_normalisation(net_head->output); /* normalizacija izlaza */
}/* ; */
/* cycle_correlation() je slicna funkciji cycle() samo sto se svaki ulaz u tezinu nekog cvora 1. sloja mnozi s ulazom pripadnog elementa, tako da za specijalni slucaj tezina dobijamo korelaciju tog elementa; funkcija ima smisla samo za ili ne-fuzzy ulaz ili characteristic2node fuzzy i to u oba slucaja samo ako je mreza generirana s overlaping */
/* uz nju se za ucenje koristi net_learn_correlation ili net_learn_limited_correlation */
void cycle_correlation(neuron *net_head)
{
characteristic *act_characteristic;
int br;
float sum;
net_head->actual_Level=net_head->first_Level;
sum=0.0;
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
(*(net_head->actual_Level->nodes+br))->actual=(*(net_head->actual_Level->nodes+br))->first;
do
{ (*(net_head->actual_Level->nodes+br))->m.notes+=(*(net_head->actual_Level->nodes+br))->first->membership*(*((float*)(act_characteristic->set)))*act_characteristic->membership;
if((*((float*)((*(net_head->actual_Level->nodes+br))->actual->set))) < ((*((float*)(act_characteristic->set)))))
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->m.notes);
sum+=(*(net_head->actual_Level->nodes+br))->m.notes;
};
if(sum<0.01)
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes+=(float)1./net_head->actual_Level->number_of_nodes;
else
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes*=1/sum;
net_head->actual_Level=net_head->actual_Level->follow;
do
{ sum=0.0;
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
do
{ (*(net_head->actual_Level->nodes+br))->m.notes += (act_characteristic->set->m.notes * act_characteristic->membership);
if((*(net_head->actual_Level->nodes+br))->actual->set->m.notesset->m.notes)
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
if(net_head->actual_Level->follow!=0)
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->m.notes);
sum+=(*(net_head->actual_Level->nodes+br))->m.notes;
};
if(sum<0.01)
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes+=(float)1.0/net_head->actual_Level->number_of_nodes;
else
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes*=1/sum;
net_head->actual_Level=net_head->actual_Level->follow;
} while(net_head->actual_Level!=0);
act_characteristic=net_head->output->first;
net_head->output->actual=act_characteristic;
do
{ act_characteristic->membership=act_characteristic->set->m.notes;
if(net_head->output->actual->set->m.notesmembership)
net_head->output->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
fuzzy_object_normalisation(net_head->output); /* normalizacija izlaza */
}/* ; */
/* set_rude() setting rude coefficients */
void set_rude( float rwT, float rwF, float rnT, float rnF)
{
extern float rude_w_T, rude_w_F, rude_n_T, rude_n_F;
rude_w_T = rwT;
rude_w_F = rwF;
rude_n_T = rnT;
rude_n_F = rnF;
} /* ; */
/* set_fine() setting fine coefficients */
void set_fine( float fwT, float fwF, float fnT, float fnF)
{
extern float fine_w_T, fine_w_F, fine_n_T, fine_n_F;
fine_w_T = fwT;
fine_w_F = fwF;
fine_n_T = fnT;
fine_n_F = fnF;
} /* ; */
/* rude_koef_learn() je funkcija koja puni koeficijente za ucenje visokim vrijednostima, a oni se prvenstveno upotrebljavaju kod prvog koraka ucenja */
void rude_koef_learn(koef_learn *k_l)
{
k_l->winner_T=rude_w_T;
k_l->winner_F=rude_w_F;
k_l->node_T=rude_n_T;
k_l->node_F=rude_n_F;
} /* ; */
/* fine_koef_learn() je funkcija koja puni koeficijente za ucenje niskim vrijednostima, a oni se prvenstveno upotrebljavaju kod drugog koraka ucenja */
void fine_koef_learn(koef_learn *k_l)
{
k_l->winner_T=fine_w_T;
k_l->winner_F= fine_w_F;
k_l->node_T=fine_n_T;
k_l->node_F=fine_n_F;
} /* ; */
/* F_normalisation() se poziva u slucaju pogresnog odgovora i djeluje kao prevencija za slucaj kada su sve tezine osim pobjednicke 0 */
void F_normalisation(fuzzy_object*head)
{
characteristic* act_characteristic;
for(act_characteristic=head->first; act_characteristic!=0; act_characteristic=act_characteristic->follow)
if(act_characteristic->membership<(float)0.0001) act_characteristic->membership=(float)0.0001;
} /* ; */
/* node_learn() je funkcija koja se poziva u net_learn, a svrha joj je u~enje (ispravljanje te`ina) danog ~vora ovisno o vrsti dobijenog odgovora (to~an ili kriv) */
void node_learn(fuzzy_object*head, enum Bool true_output, koef_learn *k_l)
{
if (true_output==T)
head->actual->membership>0.0? head->actual->membership*k_l->node_T: 0.0001*k_l->node_T; /* pobjedni~ku te`inu uve~ajemo */
else
{
head->actual->membership/= k_l->node_F; /* pobjedni~ku te`inu umanjujemo */
F_normalisation(head);
};
fuzzy_object_normalisation(head); /* postavljaju}i sumu svih te`ina na 1.0 djelujemo i na ostale te`ine prema tom ~voru koje su izgubile */
}/* ; */
/* node_winner_learn() je funkcija koja se poziva u net_learn, a svrha joj je u~enje (ispravljanje te`ina) danog ~vora, koji se nalazi na putu pobjedni~ke propagacije najve}eg izlaza, ovisno o vrsti dobijenog odgovora (to~an ili kriv) */
void node_winner_learn(backwinner *head, enum Bool true_output, koef_learn *k_l)
{
if (true_output==T)
head->weight->membership >0.0? head->weight->membership* k_l->winner_T: 0.0001* k_l->winner_T; /* pobjedni~ku te`inu uve~ajemo */
else
{
head->weight->membership /= k_l->winner_F; /* pobjedni~ku te`inu umanjujemo */
F_normalisation(head->winner);
};
fuzzy_object_normalisation(head->winner); /* postavljaju}i sumu svih te`ina na 1.0 djelujemo i na ostale te`ine prema tom ~voru koje su izgubile */
}/* ; */
/* net_learn() je funkcija za u~enje mre`e, a *true_name je vektor u koji je zapisano ime klase (osobine) u izlaznom fuzzy skupu (net_head->output); glavna ispravka se vr{i nad te`inama na koje ukazuje struktura backwinner, a manje nad te`inama svakog sloja */
void net_learn(neuron *net_head, char *true_name, p_backwinner *head_p_backwinner, koef_learn *k_l)
{
int c1;
enum Bool true_output;
backwinner *actual_backwinner;
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
} while(true_output==F);
} /* ; */
/* net_learn_correlation() je slicna funkciji net_learn() samo sto poziva cycle_correlation() mjesto cycle() */
void net_learn_correlation(neuron *net_head, char *true_name, p_backwinner *head_p_backwinner, koef_learn *k_l)
{
int c1;
enum Bool true_output;
backwinner *actual_backwinner;
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle_correlation(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
} while(true_output==F);
} /* ; */
/* net_learn_limited() je funkcija za u~enje mre`e slicna net_learn(), s jedinom razlikom sto se ucenje nastavlja i ako je odgovor tocan sve dok je clanstvo u tom odgovoru < limit, limit je realan broj izmedu 0.0 i 1.0 */
void net_learn_limited(neuron *net_head, char *true_name, p_backwinner *head_p_backwinner, koef_learn *k_l, float limit)
{
int c1;
enum Bool true_output, lim=F;
backwinner *actual_backwinner;
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
if(true_output==T)
lim=(net_head->output->actual->membership > limit)? F: T;
} while(true_output==F || lim==F);
} /* ; */
/* net_learn_limited_correlation() je slicna funkciji net_learn_limited() samo sto poziva cycle_correlation() mjesto cycle() */
void net_learn_limited_correlation(neuron *net_head, char *true_name, p_backwinner *head_p_backwinner, koef_learn *k_l, float limit)
{
int c1;
enum Bool true_output, lim=F;
backwinner *actual_backwinner;
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle_correlation(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
if(true_output==T)
lim=(net_head->output->actual->membership > limit)? F: T;
} while(true_output==F || lim==F);
} /* ; */
/* net_learn_iterationlimit() slicna je net_learn() samo sto je broj iteracija ogranicen */
void net_learn_iterationlimit(neuron *net_head, char *true_name, p_backwinner *head_p_backwinner, koef_learn *k_l, int iterationlimit)
{
int c1, iteraction=0;
enum Bool true_output;
backwinner *actual_backwinner;
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
} while((true_output==F)&&(iteraction++output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle_correlation(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
} while((true_output==F)&&(iteraction++output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
if(true_output==T)
lim=(net_head->output->actual->membership > limit)? F: T;
} while((true_output==F || lim==F)&&(iteraction++output->actual->name, true_name);
do
{ for(net_head->actual_Level=net_head->first_Level; net_head->actual_Level!=0; net_head->actual_Level=net_head->actual_Level->follow)
for(c1=0; c1actual_Level->number_of_nodes; c1++)
node_learn((*(net_head->actual_Level->nodes+c1)), true_output, k_l);
actual_backwinner=head_p_backwinner->first;
do
{ node_winner_learn(actual_backwinner, true_output, k_l);
actual_backwinner=actual_backwinner->follow;
} while(actual_backwinner!=0);
cycle_correlation(net_head);
fill_backwinner(head_p_backwinner, net_head);
true_output=check_name(net_head->output->actual->name, true_name);
if(true_output==T)
lim=(net_head->output->actual->membership > limit)? F: T;
} while((true_output==F || lim==F)&&(iteraction++number_of_characteristics=0;
head->last=(characteristic*)&(fuzzy_input->membership);
head->actual=0;
head->first=0;
head->m.notes=0.0;
return(head);
}/* ; */
/* *fill_Level1_fuzzy_input2node() is similar to *fill_Level1_fuzzy_input() with difference that the first layer just copy membership of each characteristic into node (its m.notes) that means each input's characteristic is being mapped onto its node */
Level *fill_Level1_fuzzy_input2node(int Level_No, int number_of_nodes, int nmbr_of_net_input, link_set *fuzzy_input, Level *ahead)
{
int counter, c1;
Level *head;
head=MALe((long int)1);
head->nodes=MApFO((long int)number_of_nodes);
head->Level_number=Level_No;
head->number_of_nodes=number_of_nodes;
head->ahead=ahead;
for(counter=0, c1=0; counteractual=(*(fuzzy_input+counter))->first; (*(fuzzy_input+counter))->actual!=0; (*(fuzzy_input+counter))->actual=(*(fuzzy_input+counter))->actual->follow)
(*(head->nodes+c1++))=fill_node_for_fuzzy_input2node((*(fuzzy_input+counter))->actual);
head->follow=0;
return(head);
}/* ; */
/* *fill_net_fuzzy_input2node() is similar to *fill_net_fuzzy_input() with difference that the first layer just copy membership of each characteristic into node (its m.notes) that means each input's characteristic is being mapped onto its node */
neuron *fill_net_fuzzy_input2node(char *name, int nmbr_of_Levels, int nmbr_of_net_input, int *nmbr_of_nodes, char* output_names, float *weights, link_set *fuzzy_input)
{
neuron *head;
int counter=1, counter1, counter2;
head=MAN((long int)1);
head->number_of_Levels=nmbr_of_Levels;
head->actual_Level=0;
head->name=MAC((long int)100);
head->name=read_name(head->name,name);
head->first_Level=fill_Level1_fuzzy_input2node(counter, *nmbr_of_nodes, nmbr_of_net_input, fuzzy_input, head->actual_Level);
head->actual_Level=head->first_Level;
for(counter=0; counter<(int)(head->number_of_Levels)-1; counter++)
{ head->last_Level=fill_Level((counter+2), *(nmbr_of_nodes+counter), *(nmbr_of_nodes+counter+1), weights, head->actual_Level);
for(counter1=0; counter1<*(nmbr_of_nodes+counter+1); counter1++)
for(counter2=0, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->first; (counter2<*(nmbr_of_nodes+counter))&&((*(head->last_Level->nodes+counter1))->actual!=0); counter2++, (*(head->last_Level->nodes+counter1))->actual=(*(head->last_Level->nodes+counter1))->actual->follow)
(*(head->last_Level->nodes+counter1))->actual->set=(*(head->actual_Level->nodes+counter2));
weights+=(*(nmbr_of_nodes+counter+1))*(*(nmbr_of_nodes+counter));
head->actual_Level->follow=head->last_Level;
head->actual_Level=head->last_Level;
};
head->output=net_output(head, output_names);
testfree((char*)weights);
return(head);
}/* ; */
/* *fill_net_auto_def_Lev_fuzzy_input2node() is similar to *fill_net_auto_def_Lev_fuzzy_input() with difference that the first layer just copy membership of each characteristic into node (its m.notes) that means each input's characteristic is being mapped onto its node */
neuron *fill_net_auto_def_Lev_fuzzy_input2node( char *name, int number_of_Levels, int nmbr_of_fuzzy_objects_for_input, int number_of_net_output, fuzzy_object **fuzzy_input, int *nr_of_nodes)
{
int counter, c1, counter1, counter2, *number_of_nodes;
char *output_names;
float mem, *weights;
number_of_nodes=MAI((long int)number_of_Levels);
*number_of_nodes=0;
for(counter=0; counteractual=(*(fuzzy_input+counter))->first; (*(fuzzy_input+counter))->actual!=0; (*(fuzzy_input+counter))->actual=(*(fuzzy_input+counter))->actual->follow)
(*number_of_nodes)++;
counter2=number_of_net_output*(*(nr_of_nodes+number_of_Levels-3))+(*(nr_of_nodes+number_of_Levels-3))*(*number_of_nodes);
weights=MAF((long int)counter2);
output_names=MAC((long int)(unsigned)(7+2*number_of_net_output));
*(output_names)='O';
*(output_names+1)='U';
*(output_names+2)='T';
*(output_names+3)='P';
*(output_names+4)='U';
*(output_names+5)='T';
*(output_names+6)=' ';
for(counter=0; counternumber_of_objects;
head=MApFO((long int)nr_objects);
for(i=0, k=0; inumber_of_objects; j++)
*(head+k++)=*((*(input+i))->objects+j);
return(head);
} /* ; */
/* **fuzzy_input_for_fuzzy_state_neural_network() forms state fuzzy set and then organises pointers on all fuzzy objects from fuzzy sets (input+statre) into vector*/
/* number_of_fuzzy_sets_in_input is only number of fuzzy sets pointed by input, while state fuzzy set is being added later in function */
fuzzy_object **fuzzy_input_for_fuzzy_state_neural_network(fuzzy_set **input, int number_of_fuzzy_sets_in_input, int number_of_states, int characteristics_per_state)
{
int s, c, *nmbr_characteristics;
char *f_set_name, **names;
float **memberships;
f_set_name=MAC((long int)6);
names=MApC((long int)number_of_states);
memberships=MApF(number_of_states);
nmbr_characteristics=MAI((long int)number_of_states);
*(f_set_name+0)='S';
*(f_set_name+1)='T';
*(f_set_name+2)='A';
*(f_set_name+3)='T';
*(f_set_name+4)='E';
*(f_set_name+5)=' ';
for(s=0; snumber_of_states=number_of_states;
head->characteristics_per_state=number_of_characteristics_per_state;
head->states=MApFO((long int)(int)head->number_of_states);
input_objects=fuzzy_input_for_fuzzy_state_neural_network(input, number_of_fuzzy_sets_in_input, head->number_of_states, head->characteristics_per_state);
for(i=0, nr_input_objects=0; i<(int)(number_of_fuzzy_sets_in_input)+1; i++)
nr_input_objects+=(*(input+i))->number_of_objects;
for(i=0; inumber_of_states; i++)
*(head->states+head->number_of_states-i-1)=*(input_objects+nr_input_objects-i-1);
nr_nodes=MAI((long int)1);
*nr_nodes=head->number_of_states*head->characteristics_per_state;
head->network=fill_net_auto_def_Lev_fuzzy_input2node(name, 3, nr_input_objects, number_of_net_output, input_objects, nr_nodes);
for(i=0; i<*nr_nodes; i++)
{
(*(head->network->first_Level->nodes+head->network->first_Level->number_of_nodes-i-1))->last=(characteristic*)&((*(head->network->first_Level->follow->nodes+head->network->first_Level->follow->number_of_nodes-i-1))->m.notes);
*(head->states+*nr_nodes-i-1)=*(head->network->first_Level->nodes+head->network->first_Level->number_of_nodes-i-1);
};
delete_fuzzy_set(*(input+number_of_fuzzy_sets_in_input));
testfree((char*)input_objects);
testfree((char*)nr_nodes);
return(head);
} /* ; */
/* delete_fuzzy_state_neural_network() deletes structure fuzzy_state_neural_network with all its elements (including neural network) */
void delete_fuzzy_state_neural_network(fuzzy_state_neural_network *head)
{
delete_neuron(head->network);
testfree((char*)head->states);
testfree((char*)head);
} /* ; */
/* state_normalisation() makes sum of all nodes presenting characteristics of the same state is equall 1.0 */
void state_normalisation(fuzzy_state_neural_network *head)
{
int i,j;
float sum;
for(i=0, j=0, sum=0.0; inetwork->first_Level->follow->number_of_nodes; i++)
{
sum+=(*(head->network->first_Level->follow->nodes+i))->m.notes;
if(++j==head->characteristics_per_state)
{
for(j=0; jcharacteristics_per_state; j++)
(*(head->network->first_Level->follow->nodes+i-j))->m.notes=(sum>(float)0.0)? (*(head->network->first_Level->follow->nodes+i-j))->m.notes/sum: (float)1.0/head->characteristics_per_state;
sum=0.0;
j=0;
};
};
} /* ; */
/* state_reset() reset all nodes presenting characteristics of states on 0.0 */
void state_reset(fuzzy_state_neural_network *head)
{
int i;
for(i=0; inetwork->first_Level->follow->number_of_nodes; i++)
(*(head->network->first_Level->follow->nodes+i))->m.notes=0.0;
} /* ; */
/* cycle_input2node() izvr{ava jedan ciklus rada mre`e */
void cycle_input2node(neuron *net_head)
{
characteristic *act_characteristic;
int br;
net_head->actual_Level=net_head->first_Level;
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes=*((float*)((*(net_head->actual_Level->nodes+br))->last));
net_head->actual_Level=net_head->actual_Level->follow;
do
{
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
do
{ (*(net_head->actual_Level->nodes+br))->m.notes += (act_characteristic->set->m.notes * act_characteristic->membership);
if((*(net_head->actual_Level->nodes+br))->actual->set->m.notesset->m.notes)
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
/* if(net_head->actual_Level->follow!=0) */
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->m.notes);
};
net_head->actual_Level=net_head->actual_Level->follow;
} while(net_head->actual_Level!=0);
act_characteristic=net_head->output->first;
net_head->output->actual=act_characteristic;
do
{ act_characteristic->membership=act_characteristic->set->m.notes;
if(net_head->output->actual->set->m.notesmembership)
net_head->output->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
fuzzy_object_normalisation(net_head->output); /* normalizacija izlaza */
}/* ; */
/* cycle_fsnn_without_feedback() izvr{ava jedan ciklus rada mre`e FSNN gdje se ne ucitava s ulaza koji pokazuju na drugi sloj mreze, tj. eliminira se povratna veza */
void cycle_fsnn_without_feedback(neuron *net_head)
{
characteristic *act_characteristic;
int br;
net_head->actual_Level=net_head->first_Level;
for(br=0; bractual_Level->number_of_nodes-net_head->actual_Level->follow->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes=*((float*)((*(net_head->actual_Level->nodes+br))->last));
for(br=net_head->actual_Level->number_of_nodes-net_head->actual_Level->follow->number_of_nodes; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
net_head->actual_Level=net_head->actual_Level->follow;
do
{
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
do
{ (*(net_head->actual_Level->nodes+br))->m.notes += (act_characteristic->set->m.notes * act_characteristic->membership);
if((*(net_head->actual_Level->nodes+br))->actual->set->m.notesset->m.notes)
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
/* if(net_head->actual_Level->follow!=0) */
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->m.notes);
};
net_head->actual_Level=net_head->actual_Level->follow;
} while(net_head->actual_Level!=0);
act_characteristic=net_head->output->first;
net_head->output->actual=act_characteristic;
do
{ act_characteristic->membership=act_characteristic->set->m.notes;
if(net_head->output->actual->set->m.notesmembership)
net_head->output->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
fuzzy_object_normalisation(net_head->output); /* normalizacija izlaza */
}/* ; */
/* cycle_input2node_Max() is the same as cycle_input2node() except instead of sum in calculation of node output Maximum input is proceeded into function "node_output()" */
void cycle_input2node_Max(neuron *net_head)
{
characteristic *act_characteristic;
int br;
net_head->actual_Level=net_head->first_Level;
for(br=0; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes=*((float*)((*(net_head->actual_Level->nodes+br))->last));
net_head->actual_Level=net_head->actual_Level->follow;
do
{
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
do
{
if((*(net_head->actual_Level->nodes+br))->actual->set->m.notesset->m.notes)
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
/* if(net_head->actual_Level->follow!=0) */
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->actual->set->m.notes*(*(net_head->actual_Level->nodes+br))->actual->membership);
};
net_head->actual_Level=net_head->actual_Level->follow;
} while(net_head->actual_Level!=0);
act_characteristic=net_head->output->first;
net_head->output->actual=act_characteristic;
do
{ act_characteristic->membership=act_characteristic->set->m.notes;
if(net_head->output->actual->set->m.notesmembership)
net_head->output->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
/* fuzzy_object_normalisation(net_head->output); */ /* normalizacija izlaza */
}/* ; */
/* cycle_fsnn_without_feedback_Max() is the same as cycle_fsnn_without_feedback() except instead of sum in calculation of node output Maximum input is proceeded into function "node_output()" */
void cycle_fsnn_without_feedback_Max(neuron *net_head)
{
characteristic *act_characteristic;
int br;
net_head->actual_Level=net_head->first_Level;
for(br=0; bractual_Level->number_of_nodes-(int)(net_head->actual_Level->follow->number_of_nodes); br++)
(*(net_head->actual_Level->nodes+br))->m.notes=*((float*)((*(net_head->actual_Level->nodes+br))->last));
for(br=net_head->actual_Level->number_of_nodes-net_head->actual_Level->follow->number_of_nodes; bractual_Level->number_of_nodes; br++)
(*(net_head->actual_Level->nodes+br))->m.notes=0.0;
net_head->actual_Level=net_head->actual_Level->follow;
do
{
for(br=0; bractual_Level->number_of_nodes; br++)
{ act_characteristic=(*(net_head->actual_Level->nodes+br))->first;
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
do
{ if((*(net_head->actual_Level->nodes+br))->actual->set->m.notesset->m.notes)
(*(net_head->actual_Level->nodes+br))->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
/* if(net_head->actual_Level->follow!=0) */
(*(net_head->actual_Level->nodes+br))->m.notes=node_output((*(net_head->actual_Level->nodes+br))->actual->set->m.notes*(*(net_head->actual_Level->nodes+br))->actual->membership);
};
net_head->actual_Level=net_head->actual_Level->follow;
} while(net_head->actual_Level!=0);
act_characteristic=net_head->output->first;
net_head->output->actual=act_characteristic;
do
{ act_characteristic->membership=act_characteristic->set->m.notes;
if(net_head->output->actual->set->m.notesmembership)
net_head->output->actual=act_characteristic;
act_characteristic=act_characteristic->follow;
} while(act_characteristic!=0);
fuzzy_object_normalisation(net_head->output); /* normalizacija izlaza */
}/* ; */
/* reset_BP_correction_memory_input2node() only resets weight corrections for each weight on 0.0 without affecting anything else. */
void reset_BP_correction_memory_input2node(BP_correction_memory *head)
{
int i,j;
for(i=0; i<(int)(head->network->number_of_Levels)-1; i++)
for(j=0; j<*(head->number_of_weights_per_Level+i); j++)
*(*(head->weight_correction+i)+j)=0.0;
} /* ; */
/* *BP_correction_memory_setup_input2node() forms and fills structure BP_correction_memory and setting correction weights on 0.0. "*nn" is pointer on neural network BP algorithm is going to be applied on, "learning_rate" is coefficient of learning in BP algorithm. */
BP_correction_memory *BP_correction_memory_setup_input2node(neuron *nn, float learning_rate)
{
Level *act_Level;
int i, j, k;
BP_correction_memory *head;
head=MABPCM((long int)1);
head->learning_rate=learning_rate;
head->network=nn;
head->weight_pointer=MAppCl((long int)(int)(head->network->number_of_Levels-1));
head->weight_correction=MApF((int)(head->network->number_of_Levels-1));
head->number_of_weights_per_Level=MAI((long int)(int)(head->network->number_of_Levels-1));
for(i=0, act_Level=head->network->first_Level->follow; act_Level!=0; act_Level=act_Level->follow, i++)
{
for(*(head->number_of_weights_per_Level+i)=0, j=0; jnumber_of_nodes; j++)
for((*(act_Level->nodes+j))->actual=(*(act_Level->nodes+j))->first; (*(act_Level->nodes+j))->actual!=0; (*(act_Level->nodes+j))->actual=(*(act_Level->nodes+j))->actual->follow)
(*(head->number_of_weights_per_Level+i))++;
*(head->weight_pointer+i)=MApCl((long int)(int)(*(head->number_of_weights_per_Level+i)));
*(head->weight_correction+i)=MAF((long int)(int)(*(head->number_of_weights_per_Level+i)));
for(j=0, k=0; jnumber_of_nodes; j++)
for((*(act_Level->nodes+j))->actual=(*(act_Level->nodes+j))->first; (*(act_Level->nodes+j))->actual!=0; (*(act_Level->nodes+j))->actual=(*(act_Level->nodes+j))->actual->follow)
{
*(*(head->weight_pointer+i)+k)=(*(act_Level->nodes+j))->actual;
*(*(head->weight_correction+i)+k++)=0.0;
};
};
return(head);
} /* ; */
/* delete_BP_correction_memory_input2node() deletes BP_correction_memory pointed by "*head" but not neuron pointed by its element 'neuron* network'. "*head" is pointer on structure BP_correction_memory to be deleted. */
void delete_BP_correction_memory_input2node(BP_correction_memory *head)
{
int i;
for(i=0; i<(int)(head->network->number_of_Levels)-1; i++)
{
testfree((char*)(*(head->weight_correction+i)));
testfree((char*)(*(head->weight_pointer+i)));
};
testfree((char*)head->weight_correction);
testfree((char*)head->weight_pointer);
testfree((char*)head->number_of_weights_per_Level);
testfree((char*)head);
} /* ; */
/* node_output_derivation() calculate (usually non-linear) function, gotten as the first derivation of node output (usually non-linear) function, inported as variable "value", for use in BP algorithm based learning. */
float node_output_derivation(float value)
{
extern float treasureholdadd, node_output_e_exponent;
extern char node_output_type;
float output, treasurehold=treasureholdadd;
switch(node_output_type)
{
case 'l': output=1.0; /* (value<=treasurehold)? 0.5*treasurehold: (value>1.0)? 1.0: value; */
/* in fact condition should be (value==0.0)? but because of non-existency of 0.0 in floating point arithmetic and shape of node output function previous condition fit better (node_output(treasurehold)=treasurehold */
break;
case 'e': if(value>=(float)1.0) value=(float)0.999999;
output=/* (value<=treasurehold)? 0.5*treasurehold: */ node_output_e_exponent*value*(1.0-value);
/* in fact condition should be (value==0.0)? but because of non-existency of 0.0 in floating point arithmetic and shape of node output function previous condition fit better (node_output(treasurehold)>OR=treasurehold */
break;
case 'E': if(value>=(float)1.0) value=(float)0.999999;
output=/* (value<=treasurehold)? 0.5*treasurehold: */ -(node_output_e_exponent/(float)2.0)*(value*value-(float)1.0);
/* in fact condition should be (value==0.0)? but because of non-existency of 0.0 in floating point arithmetic and shape of node output function previous condition fit better (node_output(treasurehold)>OR=treasurehold */
break;
break;
case 't': if(value>=(float)1.0) value=(float)0.999999;
output=(value<=treasurehold)? (float)0.5*treasurehold: (float)((float)0.5*M_PI*((float)1.0-value));
/* in fact condition should be (value==0.0)? but because of non-existency of 0.0 in floating point arithmetic and shape of node output function previous condition fit better (node_output(treasurehold)>OR=treasurehold */
break;
case 'T': if(value>=(float)1.0) value=(float)0.999999;
output=(value<=treasurehold)? (float)0.5*treasurehold: (float)(M_PI*((float)1.0-value));
/* in fact condition should be (value==0.0)? but because of non-existency of 0.0 in floating point arithmetic and shape of node output function previous condition fit better (node_output(treasurehold)>OR=treasurehold */
break;
default: output=value;
break;
} /* ; */
return(output);
}/* ; */
/* BP_learn_cycle_input2node() calculates weight corrections for neural network pointed inside structure BP_correction_memory pointed by "*memory" according vector of expected answers. Network output is red from last Level's node's m.notes rather than from output fuzzy set. "*memory" is pointer on BP_correction_memory consists pointer on neural network and used to store weight corrections (by incrementing previous weight correction for each weight), "*expected_output" is pointer on expected value of each node output (equivalent to output fuzzy set each characteristic membership) in the same order as characteristics in output fuzzy set (as last Level nodes). */
/* NOTE: BP_learn_cycle_input2node() doesn't correct weights. To do so one needs to call function BP_weight_correction_input2node() after this. */
/* Used BackPropagation algorithm is from IEEE "Neural Networks Theoretical Foundations and Analysis", pp.211-221, article "Backpropagation Through Time: What It Does and How to Do It" by P.J. Werbos */
void BP_learn_cycle_input2node(BP_correction_memory *memory, float *expected_output)
{
int i, j, k;
float **neti, *new_state_value;
/* "**neti" is pointer to vectors (each for its Level) consisting node output neti (the same label as in the literature) */
/* in this case neural network has 3 Levels: 1st is input and previous state, 2nd is actual state, 3rd is output. "*new_state_value" vector memorises calculated values of actual state vector according BP algorithm. Actual state values are later repleced with ones stored in "*new_state_value" vector so error in weight calculation doesn't propagate into next step (next "cycle_input2node"). */
neti=MApF((int)(memory->network->number_of_Levels-1));
new_state_value=MAF((long int)(int)memory->network->first_Level->follow->number_of_nodes);
for(i=0, memory->network->actual_Level=memory->network->first_Level->follow; i<(int)(memory->network->number_of_Levels)-1; i++, memory->network->actual_Level=memory->network->actual_Level->follow)
*(neti+i)=MAF((long int)(int)memory->network->actual_Level->number_of_nodes);
memory->network->actual_Level=memory->network->last_Level;
j=memory->network->number_of_Levels-2;
for(i=0; inetwork->actual_Level->number_of_nodes; i++)
*(*(neti+j)+i)=node_output_derivation((*(memory->network->actual_Level->nodes+i))->m.notes)*((*(memory->network->actual_Level->nodes+i))->m.notes-(*(expected_output+i)));
j--;
memory->network->actual_Level=memory->network->actual_Level->ahead;
do
{
for(i=0; inetwork->actual_Level->number_of_nodes; i++)
{
*(*(neti+j)+i)=0.0;
for(k=0; knetwork->actual_Level->follow->number_of_nodes; k++)
{
for((*(memory->network->actual_Level->follow->nodes+k))->actual=(*(memory->network->actual_Level->follow->nodes+k))->first; (*(memory->network->actual_Level->follow->nodes+k))->actual->set!=*(memory->network->actual_Level->nodes+i); (*(memory->network->actual_Level->follow->nodes+k))->actual=(*(memory->network->actual_Level->follow->nodes+k))->actual->follow);
*(*(neti+j)+i)+=(*(memory->network->actual_Level->follow->nodes+k))->actual->membership*(*(*(neti+j+1)+k));
};
if(memory->network->actual_Level==memory->network->first_Level->follow) *(new_state_value+i)=*(*(neti+j)+i);
*(*(neti+j)+i)*=node_output_derivation((*(memory->network->actual_Level->nodes+i))->m.notes);
};
j--;
memory->network->actual_Level=memory->network->actual_Level->ahead;
}
while(memory->network->actual_Level!=memory->network->first_Level);
for(j=0, memory->network->actual_Level=memory->network->first_Level->follow; j<(int)(memory->network->number_of_Levels)-1; j++, memory->network->actual_Level=memory->network->actual_Level->follow)
for(i=0, k=0; inetwork->actual_Level->number_of_nodes; i++)
for((*(memory->network->actual_Level->nodes+i))->actual=(*(memory->network->actual_Level->nodes+i))->first; (*(memory->network->actual_Level->nodes+i))->actual!=0; (*(memory->network->actual_Level->nodes+i))->actual=(*(memory->network->actual_Level->nodes+i))->actual->follow)
(*(*(memory->weight_correction+j)+k++))+=*(*(neti+j)+i)*(*(memory->network->actual_Level->nodes+i))->actual->set->m.notes;
for(j=0; jnetwork->first_Level->follow->number_of_nodes; j++)
(*(memory->network->first_Level->follow->nodes+j))->m.notes=node_output(*(new_state_value+j));
for(i=0, memory->network->actual_Level=memory->network->first_Level->follow; i<(int)(memory->network->number_of_Levels)-1; i++, memory->network->actual_Level=memory->network->actual_Level->follow)
testfree((char*)(*(neti+i)));
testfree((char*)neti);
testfree((char*)new_state_value);
} /* ; */
/* BP_learn_cycle_fsnn_without_feedback() is similar to BP_learn_cycle_input2node() with the difference inputs correspond previous state (pointing to second Level's nodes) are not taken in calculation. */
/* NOTE: BP_learn_cycle_fsnn_without_feedback() doesn't correct weights. To do so one needs to call function BP_weight_correction_input2node() after this. */
/* Used BackPropagation algorithm is from IEEE "Neural Networks Theoretical Foundations and Analysis", pp.211-221, article "Backpropagation Through Time: What It Does and How to Do It" by P.J. Werbos */
void BP_learn_cycle_fsnn_without_feedback(BP_correction_memory *memory, float *expected_output)
{
int i, j, k, l;
float **neti;
/* "**neti" is pointer to vectors (each for its Level) consisting node output neti (the same label as in the literature) */
/* in this case neural network has 3 Levels: 1st is input and previous state, 2nd is actual state, 3rd is output. "*new_state_value" vector memorises calculated values of actual state vector according BP algorithm. Actual state values are later repleced with ones stored in "*new_state_value" vector so error in weight calculation doesn't propagate into next step (next "cycle_input2node"). */
neti=MApF((int)(memory->network->number_of_Levels-1));
for(i=0, memory->network->actual_Level=memory->network->first_Level->follow; i<(int)(memory->network->number_of_Levels)-1; i++, memory->network->actual_Level=memory->network->actual_Level->follow)
*(neti+i)=MAF((long int)(int)memory->network->actual_Level->number_of_nodes);
memory->network->actual_Level=memory->network->last_Level;
j=memory->network->number_of_Levels-2;
for(i=0; inetwork->actual_Level->number_of_nodes; i++)
*(*(neti+j)+i)=node_output_derivation((*(memory->network->actual_Level->nodes+i))->m.notes)*((*(memory->network->actual_Level->nodes+i))->m.notes-(*(expected_output+i)));
j--;
memory->network->actual_Level=memory->network->actual_Level->ahead;
do
{
for(i=0; inetwork->actual_Level->number_of_nodes; i++)
{
*(*(neti+j)+i)=0.0;
for(k=0; knetwork->actual_Level->follow->number_of_nodes; k++)
{
for((*(memory->network->actual_Level->follow->nodes+k))->actual=(*(memory->network->actual_Level->follow->nodes+k))->first; (*(memory->network->actual_Level->follow->nodes+k))->actual->set!=*(memory->network->actual_Level->nodes+i); (*(memory->network->actual_Level->follow->nodes+k))->actual=(*(memory->network->actual_Level->follow->nodes+k))->actual->follow);
*(*(neti+j)+i)+=(*(memory->network->actual_Level->follow->nodes+k))->actual->membership*(*(*(neti+j+1)+k));
};
*(*(neti+j)+i)*=node_output_derivation((*(memory->network->actual_Level->nodes+i))->m.notes);
};
j--;
memory->network->actual_Level=memory->network->actual_Level->ahead;
}
while(memory->network->actual_Level!=memory->network->first_Level);
for(j=0, memory->network->actual_Level=memory->network->first_Level->follow; j<(int)(memory->network->number_of_Levels)-1; j++, memory->network->actual_Level=memory->network->actual_Level->follow)
for(i=0, k=0; inetwork->actual_Level->number_of_nodes; i++)
for(l=1, (*(memory->network->actual_Level->nodes+i))->actual=(*(memory->network->actual_Level->nodes+i))->first; (*(memory->network->actual_Level->nodes+i))->actual!=0; (*(memory->network->actual_Level->nodes+i))->actual=(*(memory->network->actual_Level->nodes+i))->actual->follow, l++)
if((memory->network->actual_Level==memory->network->first_Level->follow)&&(l>memory->network->first_Level->number_of_nodes-memory->network->first_Level->follow->number_of_nodes))
(*(*(memory->weight_correction+j)+k++))+=0.0;
else
(*(*(memory->weight_correction+j)+k++))+=*(*(neti+j)+i)*(*(memory->network->actual_Level->nodes+i))->actual->set->m.notes;
for(i=0, memory->network->actual_Level=memory->network->first_Level->follow; i<(int)(memory->network->number_of_Levels)-1; i++, memory->network->actual_Level=memory->network->actual_Level->follow)
testfree((char*)(*(neti+i)));
testfree((char*)neti);
} /* ; */
/* BP_weight_correction_input2node() changes weight of neural network pointed in structure "*memory" according structure BP_correction_memory, pointed by "*memory", elements learning_rate and weight corrections stored in element weight_correction. "*memory" points on structure BP_correction_memory consists information of neural network whose weights will be updated as well as information of weights update and learning coefficient (learning_rate). */
/* NOTE: BP_weight_correction_input2node() doesn't reset weights correction on 0.0. To perform that one needs to call function reset_BP_correction_memory_input2node() after this function. */
void BP_weight_correction_input2node(BP_correction_memory *memory)
{
int i, j;
for(i=0; i<(int)(memory->network->number_of_Levels)-1; i++)
for(j=0; j<*(memory->number_of_weights_per_Level+i); j++)
(*(*(memory->weight_pointer+i)+j))->membership=(memory->learning_rate*(*(*(memory->weight_correction+i)+j))>(*(*(memory->weight_pointer+i)+j))->membership)+1.? (float)-1.:(memory->learning_rate*(*(*(memory->weight_correction+i)+j))<(*(*(memory->weight_pointer+i)+j))->membership-1.0)? (float)1.0:(*(*(memory->weight_pointer+i)+j))->membership-memory->learning_rate*(*(*(memory->weight_correction+i)+j));
} /* ; */
/* float abs_sum_BP_weight_corrections() calculate absolute sum (sum of absolute values) of all weight corrections */
float abs_sum_BP_weight_corrections(BP_correction_memory *memory)
{
int i, j;
double sum=0.0;
for(i=0; i<(int)(memory->network->number_of_Levels)-1; i++)
for(j=0; j<*(memory->number_of_weights_per_Level+i); j++)
sum+=sqrt((double)((*(*(memory->weight_correction+i)+j))*(*(*(memory->weight_correction+i)+j))));
return((float)sum);
} /* ; */
/* functions for setting up NEURON TYPE DESCRIPTORs */
/* setting up highest_difference_from_neighborns descriptor */
/* neuron_type_descriptor* setup_highest_difference_from_neighborns_descriptor() sets up neuron_type_descriptor for highest_difference_from_neighborns class of neurones */
neuron_type_descriptor* setup_highest_difference_from_neighborns_descriptor()
{
neuron_type_descriptor* highest_difference_from_neighborns;
highest_difference_from_neighborns=MANTD((long int)1);
highest_difference_from_neighborns->name=MAC((long int)39);
*(highest_difference_from_neighborns->name+0)='t';
*(highest_difference_from_neighborns->name+1)='h';
*(highest_difference_from_neighborns->name+2)='e';
*(highest_difference_from_neighborns->name+3)='_';
*(highest_difference_from_neighborns->name+4)='h';
*(highest_difference_from_neighborns->name+5)='i';
*(highest_difference_from_neighborns->name+6)='g';
*(highest_difference_from_neighborns->name+7)='h';
*(highest_difference_from_neighborns->name+8)='e';
*(highest_difference_from_neighborns->name+9)='s';
*(highest_difference_from_neighborns->name+10)='t';
*(highest_difference_from_neighborns->name+11)='_';
*(highest_difference_from_neighborns->name+12)='d';
*(highest_difference_from_neighborns->name+13)='i';
*(highest_difference_from_neighborns->name+14)='f';
*(highest_difference_from_neighborns->name+15)='f';
*(highest_difference_from_neighborns->name+16)='e';
*(highest_difference_from_neighborns->name+17)='r';
*(highest_difference_from_neighborns->name+18)='e';
*(highest_difference_from_neighborns->name+19)='n';
*(highest_difference_from_neighborns->name+20)='c';
*(highest_difference_from_neighborns->name+21)='e';
*(highest_difference_from_neighborns->name+22)='_';
*(highest_difference_from_neighborns->name+23)='f';
*(highest_difference_from_neighborns->name+24)='r';
*(highest_difference_from_neighborns->name+25)='o';
*(highest_difference_from_neighborns->name+26)='m';
*(highest_difference_from_neighborns->name+27)='_';
*(highest_difference_from_neighborns->name+28)='n';
*(highest_difference_from_neighborns->name+29)='e';
*(highest_difference_from_neighborns->name+30)='i';
*(highest_difference_from_neighborns->name+31)='g';
*(highest_difference_from_neighborns->name+32)='h';
*(highest_difference_from_neighborns->name+33)='b';
*(highest_difference_from_neighborns->name+34)='o';
*(highest_difference_from_neighborns->name+35)='r';
*(highest_difference_from_neighborns->name+36)='n';
*(highest_difference_from_neighborns->name+37)='s';
*(highest_difference_from_neighborns->name+38)=' ';
highest_difference_from_neighborns->number_of_Levels=2;
highest_difference_from_neighborns->inputs_per_first_Level_node=1+8;
highest_difference_from_neighborns->nodes_per_Level=MAI((long int)highest_difference_from_neighborns->number_of_Levels);
*(highest_difference_from_neighborns->nodes_per_Level+0)=8;
*(highest_difference_from_neighborns->nodes_per_Level+1)=1;
highest_difference_from_neighborns->recurrence=F;
highest_difference_from_neighborns->number_of_recurrent_connected_layers=0;
highest_difference_from_neighborns->source=0;
highest_difference_from_neighborns->destination=0;
highest_difference_from_neighborns->number_of_functions_for_creating_neuron=1;
highest_difference_from_neighborns->create_neuron=(void**)testmalloc((size_t)highest_difference_from_neighborns->number_of_functions_for_creating_neuron*sizeof(void*));
if(highest_difference_from_neighborns->create_neuron==0) exit_handling(4,1);
*(highest_difference_from_neighborns->create_neuron+0)=create_highest_difference_from_neighborns;
highest_difference_from_neighborns->create_neuron_population=create_neuron_population;
highest_difference_from_neighborns->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
highest_difference_from_neighborns->number_linear_output_functions=1;
highest_difference_from_neighborns->node_linear_output=(void**)testmalloc((size_t)highest_difference_from_neighborns->number_linear_output_functions*sizeof(void*));
if(highest_difference_from_neighborns->node_linear_output==0) exit_handling(4,2);
*(highest_difference_from_neighborns->node_linear_output)=even_minus_odd;
highest_difference_from_neighborns->number_of_node_output_functions=5;
highest_difference_from_neighborns->node_output=(void**)testmalloc((size_t)highest_difference_from_neighborns->number_of_node_output_functions*sizeof(void*));
if(highest_difference_from_neighborns->node_output==0) exit_handling(4,3);
*(highest_difference_from_neighborns->node_output+0)=exp_node_output;
*(highest_difference_from_neighborns->node_output+1)=exp_positive_node_output;
*(highest_difference_from_neighborns->node_output+2)=tgh_node_output;
*(highest_difference_from_neighborns->node_output+3)=treasureholded_node_output;
*(highest_difference_from_neighborns->node_output+4)=unchanged_linear_node_output;
highest_difference_from_neighborns->node_output_derivation=(void**)testmalloc((size_t)highest_difference_from_neighborns->number_of_node_output_functions*sizeof(void*));
if(highest_difference_from_neighborns->node_output_derivation==0) exit_handling(4,4);
*(highest_difference_from_neighborns->node_output_derivation+0)=exp_node_output_derivation;
*(highest_difference_from_neighborns->node_output_derivation+1)=exp_positive_node_output_derivation;
*(highest_difference_from_neighborns->node_output_derivation+2)=tgh_node_output_derivation;
*(highest_difference_from_neighborns->node_output_derivation+3)=treasureholded_node_output_derivation;
*(highest_difference_from_neighborns->node_output_derivation+4)=unchanged_linear_node_output_derivation;
highest_difference_from_neighborns->number_of_firing_functions=1;
highest_difference_from_neighborns->firing_neuron=(void**)testmalloc((size_t)highest_difference_from_neighborns->number_of_firing_functions*sizeof(void*));
if(highest_difference_from_neighborns->firing_neuron==0) exit_handling(4,5);
*(highest_difference_from_neighborns->firing_neuron)=firing_highest_difference_from_neighborns;
highest_difference_from_neighborns->number_of_learning_algorithms=1; /* this type of neuron is not expected/proposed to learn */
highest_difference_from_neighborns->create_learning_algorithm=(void**)testmalloc((size_t)highest_difference_from_neighborns->number_of_learning_algorithms*sizeof(void*));
if(highest_difference_from_neighborns->create_learning_algorithm==0) exit_handling(4,6);
*(highest_difference_from_neighborns->create_learning_algorithm+0)=BP_HDFN_without_learning_algorithm_setup; /* this type of neuron is not expected/proposed to learn */
return(highest_difference_from_neighborns);
} /* ; */
/* setting up corner_extractor descriptor */
/* neuron_type_descriptor* setup_corner_extractor_descriptor() sets up neuron_type_descriptor for corner_extractor class of neurones */
neuron_type_descriptor* setup_corner_extractor_descriptor()
{
neuron_type_descriptor* corner_extractor;
corner_extractor=MANTD((long int)1);
corner_extractor->name=MAC((long int)17);
*(corner_extractor->name+0)='c';
*(corner_extractor->name+1)='o';
*(corner_extractor->name+2)='r';
*(corner_extractor->name+3)='n';
*(corner_extractor->name+4)='e';
*(corner_extractor->name+5)='r';
*(corner_extractor->name+6)='_';
*(corner_extractor->name+7)='e';
*(corner_extractor->name+8)='x';
*(corner_extractor->name+9)='t';
*(corner_extractor->name+10)='r';
*(corner_extractor->name+11)='a';
*(corner_extractor->name+12)='c';
*(corner_extractor->name+13)='t';
*(corner_extractor->name+14)='o';
*(corner_extractor->name+15)='r';
*(corner_extractor->name+16)=' ';
corner_extractor->number_of_Levels=3;
corner_extractor->inputs_per_first_Level_node=1+8;
corner_extractor->nodes_per_Level=MAI((long int)corner_extractor->number_of_Levels);
*(corner_extractor->nodes_per_Level+0)=8;
*(corner_extractor->nodes_per_Level+1)=2;
*(corner_extractor->nodes_per_Level+2)=1;
corner_extractor->recurrence=F;
corner_extractor->number_of_recurrent_connected_layers=0;
corner_extractor->source=0;
corner_extractor->destination=0;
corner_extractor->number_of_functions_for_creating_neuron=1;
corner_extractor->create_neuron=(void**)testmalloc((size_t)corner_extractor->number_of_functions_for_creating_neuron*sizeof(void*));
if(corner_extractor->create_neuron==0) exit_handling(5,1);
*(corner_extractor->create_neuron)=create_corner_extractor;
corner_extractor->create_neuron_population=create_neuron_population;
corner_extractor->prepare_input=preparing_corner_extractor_neuron_population_neuron_inputs_through_window;
corner_extractor->number_linear_output_functions=4;
corner_extractor->node_linear_output=(void**)testmalloc((size_t)corner_extractor->number_linear_output_functions*sizeof(void*));
if(corner_extractor->node_linear_output==0) exit_handling(5,2);
*(corner_extractor->node_linear_output)=sum_of_2multiplications_with_maximum_of_3;
*(corner_extractor->node_linear_output+1)=sum_of_roots_of_2multiplications_with_maximum_of_3;
*(corner_extractor->node_linear_output+2)=arithmetic_mean_of_roots_of_2multiplications_with_maximum_of_3;
*(corner_extractor->node_linear_output+3)=highest_arithmetic_mean_of_2_with_maximum_of_3;
corner_extractor->number_of_node_output_functions=5;
corner_extractor->node_output=(void**)testmalloc((size_t)corner_extractor->number_of_node_output_functions*sizeof(void*));
if(corner_extractor->node_output==0) exit_handling(5,3);
*(corner_extractor->node_output+0)=exp_node_output;
*(corner_extractor->node_output+1)=exp_positive_node_output;
*(corner_extractor->node_output+2)=tgh_node_output;
*(corner_extractor->node_output+3)=treasureholded_node_output;
*(corner_extractor->node_output+4)=unchanged_linear_node_output;
corner_extractor->node_output_derivation=(void**)testmalloc((size_t)corner_extractor->number_of_node_output_functions*sizeof(void*));
if(corner_extractor->node_output_derivation==0) exit_handling(5,4);
*(corner_extractor->node_output_derivation+0)=exp_node_output_derivation;
*(corner_extractor->node_output_derivation+1)=exp_positive_node_output_derivation;
*(corner_extractor->node_output_derivation+1)=tgh_node_output_derivation;
*(corner_extractor->node_output_derivation+2)=treasureholded_node_output_derivation;
*(corner_extractor->node_output_derivation+1)=unchanged_linear_node_output_derivation;
corner_extractor->number_of_firing_functions=1;
corner_extractor->firing_neuron=(void**)testmalloc((size_t)corner_extractor->number_of_firing_functions*sizeof(void*));
if(corner_extractor->firing_neuron==0) exit_handling(5,5);
*(corner_extractor->firing_neuron+0)=firing_corner_extractor;
corner_extractor->number_of_learning_algorithms=1; /* this type of neuron is not expected/proposed to learn */
corner_extractor->create_learning_algorithm=(void**)testmalloc((size_t)corner_extractor->number_of_learning_algorithms*sizeof(void*));
if(corner_extractor->create_learning_algorithm==0) exit_handling(5,6);
*(corner_extractor->create_learning_algorithm+0)=BP_CE_without_learning_algorithm_setup; /* this type of neuron is not expected/proposed to learn */
return(corner_extractor);
} /* ; */
/* setting up sort2 descriptor */
/* neuron_type_descriptor* setup_sort2_descriptor() sets up neuron_type_descriptor for sort2 class of neurones */
neuron_type_descriptor* setup_sort2_descriptor()
{
neuron_type_descriptor* sort2;
sort2=MANTD((long int)1);
sort2->name=MAC((long int)6);
*(sort2->name+0)='s';
*(sort2->name+1)='o';
*(sort2->name+2)='r';
*(sort2->name+3)='t';
*(sort2->name+4)='2';
*(sort2->name+5)=' ';
sort2->number_of_Levels=2;
sort2->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
sort2->nodes_per_Level=MAI((long int)sort2->number_of_Levels);
*(sort2->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(sort2->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are in the 1st Level */
sort2->recurrence=F;
sort2->number_of_recurrent_connected_layers=0;
sort2->source=0;
sort2->destination=0;
sort2->number_of_functions_for_creating_neuron=1;
sort2->create_neuron=(void**)testmalloc((size_t)sort2->number_of_functions_for_creating_neuron*sizeof(void*));
if(sort2->create_neuron==0) exit_handling(11,1);
*(sort2->create_neuron)=create_sort2;
sort2->create_neuron_population=create_neuron_population;
sort2->prepare_input=0;
sort2->number_linear_output_functions=2;
sort2->node_linear_output=(void**)testmalloc((size_t)sort2->number_linear_output_functions*sizeof(void*));
if(sort2->node_linear_output==0) exit_handling(11,2);
*(sort2->node_linear_output)=sort2_first_Level;
*(sort2->node_linear_output+1)=sort2_second_Level;
sort2->number_of_node_output_functions=1;
sort2->node_output=(void**)testmalloc((size_t)sort2->number_of_node_output_functions*sizeof(void*));
if(sort2->node_output==0) exit_handling(11,3);
*(sort2->node_output+0)=unchanged_linear_node_output;
sort2->node_output_derivation=(void**)testmalloc((size_t)sort2->number_of_node_output_functions*sizeof(void*));
if(sort2->node_output_derivation==0) exit_handling(11,4);
*(sort2->node_output_derivation+0)=unchanged_linear_node_output_derivation;;
sort2->number_of_firing_functions=1;
sort2->firing_neuron=(void**)testmalloc((size_t)sort2->number_of_firing_functions*sizeof(void*));
if(sort2->firing_neuron==0) exit_handling(11,5);
*(sort2->firing_neuron)=firing_sort2;
sort2->number_of_learning_algorithms=1; /* this type of neuron is not expected/proposed to learn */
sort2->create_learning_algorithm=(void**)testmalloc((size_t)sort2->number_of_learning_algorithms*sizeof(void*));
if(sort2->create_learning_algorithm==0) exit_handling(11,6);
*(sort2->create_learning_algorithm)=BP_sort2_without_learning_algorithm_setup; /* this type of neuron is not expected/proposed to learn */
return(sort2);
} /* ; */
/* setting up number_of_corner_extractor descriptor */
/* neuron_type_descriptor* setup_number_of_corner_extractor_descriptor() sets up neuron_type_descriptor for number_of_corner_extractor class of neurones */
neuron_type_descriptor* setup_number_of_corner_extractor_descriptor()
{
neuron_type_descriptor* number_of_corner_extractor;
number_of_corner_extractor=MANTD((long int)1);
number_of_corner_extractor->name=MAC((long int)17);
*(number_of_corner_extractor->name+0)='n';
*(number_of_corner_extractor->name+1)='u';
*(number_of_corner_extractor->name+2)='m';
*(number_of_corner_extractor->name+3)='b';
*(number_of_corner_extractor->name+4)='e';
*(number_of_corner_extractor->name+5)='r';
*(number_of_corner_extractor->name+6)='_';
*(number_of_corner_extractor->name+7)='o';
*(number_of_corner_extractor->name+8)='f';
*(number_of_corner_extractor->name+9)='_';
*(number_of_corner_extractor->name+10)='c';
*(number_of_corner_extractor->name+11)='o';
*(number_of_corner_extractor->name+12)='r';
*(number_of_corner_extractor->name+13)='n';
*(number_of_corner_extractor->name+14)='e';
*(number_of_corner_extractor->name+15)='r';
*(number_of_corner_extractor->name+16)='_';
*(number_of_corner_extractor->name+17)='e';
*(number_of_corner_extractor->name+18)='x';
*(number_of_corner_extractor->name+19)='t';
*(number_of_corner_extractor->name+20)='r';
*(number_of_corner_extractor->name+21)='a';
*(number_of_corner_extractor->name+22)='c';
*(number_of_corner_extractor->name+23)='t';
*(number_of_corner_extractor->name+24)='o';
*(number_of_corner_extractor->name+25)='r';
*(number_of_corner_extractor->name+26)=' ';
number_of_corner_extractor->number_of_Levels=1;
number_of_corner_extractor->inputs_per_first_Level_node=0; /* means all inputs are associated with the 1st Level node */
number_of_corner_extractor->nodes_per_Level=MAI((long int)number_of_corner_extractor->number_of_Levels);
*(number_of_corner_extractor->nodes_per_Level+0)=1;
number_of_corner_extractor->recurrence=F;
number_of_corner_extractor->number_of_recurrent_connected_layers=0;
number_of_corner_extractor->source=0;
number_of_corner_extractor->destination=0;
number_of_corner_extractor->number_of_functions_for_creating_neuron=1;
number_of_corner_extractor->create_neuron=(void**)testmalloc((size_t)number_of_corner_extractor->number_of_functions_for_creating_neuron*sizeof(void*));
if(number_of_corner_extractor->create_neuron==0) exit_handling(17,1);
*(number_of_corner_extractor->create_neuron)=create_number_of_corner_extractor;
number_of_corner_extractor->create_neuron_population=create_neuron_population;
number_of_corner_extractor->prepare_input=preparing_number_of_corner_extractor_neuron_population_neuron_inputs; /* Enables usage of common create neuron population function. For each neuron input fuzzy set is created (point on input fuzzy set's fuzzy objects) with its name consisting (NOT pointing on) the number of corners possibility of is to be extracted */
/* input should be prepared by preprocessing throught "sort"NN */
number_of_corner_extractor->number_linear_output_functions=1;
number_of_corner_extractor->node_linear_output=(void**)testmalloc((size_t)number_of_corner_extractor->number_linear_output_functions*sizeof(void*));
if(number_of_corner_extractor->node_linear_output==0) exit_handling(17,2);
*(number_of_corner_extractor->node_linear_output+0)=product_of_first_n_with_complements_of_rest;
number_of_corner_extractor->number_of_node_output_functions=5;
number_of_corner_extractor->node_output=(void**)testmalloc((size_t)number_of_corner_extractor->number_of_node_output_functions*sizeof(void*));
if(number_of_corner_extractor->node_output==0) exit_handling(17,3);
*(number_of_corner_extractor->node_output+0)=exp_node_output;
*(number_of_corner_extractor->node_output+1)=exp_positive_node_output;
*(number_of_corner_extractor->node_output+2)=tgh_node_output;
*(number_of_corner_extractor->node_output+3)=treasureholded_node_output;
*(number_of_corner_extractor->node_output+4)=unchanged_linear_node_output_derivation;
number_of_corner_extractor->node_output_derivation=(void**)testmalloc((size_t)number_of_corner_extractor->number_of_node_output_functions*sizeof(void*));
if(number_of_corner_extractor->node_output_derivation==0) exit_handling(17,4);
*(number_of_corner_extractor->node_output_derivation+0)=exp_node_output_derivation;
*(number_of_corner_extractor->node_output_derivation+1)=exp_positive_node_output_derivation;
*(number_of_corner_extractor->node_output_derivation+1)=tgh_node_output_derivation;
*(number_of_corner_extractor->node_output_derivation+2)=treasureholded_node_output_derivation;
*(number_of_corner_extractor->node_output_derivation+1)=treasureholded_node_output_derivation;
number_of_corner_extractor->number_of_firing_functions=1;
number_of_corner_extractor->firing_neuron=(void**)testmalloc((size_t)number_of_corner_extractor->number_of_firing_functions*sizeof(void*));
if(number_of_corner_extractor->firing_neuron==0) exit_handling(17,5);
*(number_of_corner_extractor->firing_neuron+0)=firing_number_of_corner_extractor;
number_of_corner_extractor->number_of_learning_algorithms=1; /* this type of neuron is not expected/proposed to learn */
number_of_corner_extractor->create_learning_algorithm=(void**)testmalloc((size_t)number_of_corner_extractor->number_of_learning_algorithms*sizeof(void*));
if(number_of_corner_extractor->create_learning_algorithm==0) exit_handling(17,6);
*(number_of_corner_extractor->create_learning_algorithm+0)=BP_NCE_without_learning_algorithm_setup; /* this type of neuron is not expected/proposed to learn */
return(number_of_corner_extractor);
} /* ; */
/* setting up area separator descriptor */
/* neuron_type_descriptor* setup_area_separator_descriptor() sets up neuron_type_descriptor for area separator class of neurones */
neuron_type_descriptor* setup_area_separator_descriptor()
{
neuron_type_descriptor* area_separator;
area_separator=MANTD((long int)1);
area_separator->name=MAC((long int)15);
*(area_separator->name+0)='a';
*(area_separator->name+1)='r';
*(area_separator->name+2)='e';
*(area_separator->name+3)='a';
*(area_separator->name+4)='_';
*(area_separator->name+5)='s';
*(area_separator->name+6)='e';
*(area_separator->name+7)='p';
*(area_separator->name+8)='a';
*(area_separator->name+9)='r';
*(area_separator->name+10)='a';
*(area_separator->name+11)='t';
*(area_separator->name+12)='o';
*(area_separator->name+13)='r';
*(area_separator->name+14)=' ';
area_separator->number_of_Levels=2;
area_separator->inputs_per_first_Level_node=1+8; /* means its associated input and outputs of its neighbouring nodes (8 of them) */
area_separator->nodes_per_Level=MAI((long int)area_separator->number_of_Levels);
*(area_separator->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(area_separator->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are in the 1st Level */
area_separator->recurrence=F;
area_separator->number_of_recurrent_connected_layers=0;
area_separator->source=0;
area_separator->destination=0;
area_separator->number_of_functions_for_creating_neuron=1;
area_separator->create_neuron=(void**)testmalloc((size_t)area_separator->number_of_functions_for_creating_neuron*sizeof(void*));
if(area_separator->create_neuron==0) exit_handling(19,1);
*(area_separator->create_neuron)=create_area_separator;
area_separator->create_neuron_population=create_neuron_population;
area_separator->prepare_input=preparing_area_separator_neuron_population_neuron_inputs;
area_separator->number_linear_output_functions=2;
area_separator->node_linear_output=(void**)testmalloc((size_t)area_separator->number_linear_output_functions*sizeof(void*));
if(area_separator->node_linear_output==0) exit_handling(19,2);
*(area_separator->node_linear_output+0)=area_separator_all_Levels;
*(area_separator->node_linear_output+1)=area_without_edges_separator_all_Levels;
area_separator->number_of_node_output_functions=5;
area_separator->node_output=(void**)testmalloc((size_t)area_separator->number_of_node_output_functions*sizeof(void*));
if(area_separator->node_output==0) exit_handling(19,3);
*(area_separator->node_output+0)=unchanged_linear_node_output;
*(area_separator->node_output+1)=exp_node_output;
*(area_separator->node_output+2)=exp_positive_node_output;
*(area_separator->node_output+3)=tgh_node_output;
*(area_separator->node_output+4)=treasureholded_node_output;
area_separator->node_output_derivation=(void**)testmalloc((size_t)area_separator->number_of_node_output_functions*sizeof(void*));
if(area_separator->node_output_derivation==0) exit_handling(19,4);
*(area_separator->node_output_derivation+0)=unchanged_linear_node_output_derivation;
*(area_separator->node_output_derivation+1)=exp_node_output_derivation;
*(area_separator->node_output_derivation+2)=exp_positive_node_output_derivation;
*(area_separator->node_output_derivation+2)=tgh_node_output_derivation;
*(area_separator->node_output_derivation+3)=treasureholded_node_output_derivation;
area_separator->number_of_firing_functions=2;
area_separator->firing_neuron=(void**)testmalloc((size_t)area_separator->number_of_firing_functions*sizeof(void*));
if(area_separator->firing_neuron==0) exit_handling(19,5);
*(area_separator->firing_neuron+0)=firing_area_separator;
*(area_separator->firing_neuron+1)=firing_area_without_edges_separator;
area_separator->number_of_learning_algorithms=1; /* this type of neuron is not expected/proposed to learn */
area_separator->create_learning_algorithm=(void**)testmalloc((size_t)area_separator->number_of_learning_algorithms*sizeof(void*));
if(area_separator->create_learning_algorithm==0) exit_handling(19,6);
*(area_separator->create_learning_algorithm+0)=BP_AS_without_learning_algorithm_setup; /* this type of neuron is not expected/proposed to learn */
return(area_separator);
} /* ; */
/* setting up area without edges separator descriptor */
/* neuron_type_descriptor* setup_area_without_edges_separator_descriptor() sets up neuron_type_descriptor for area without edges separator class of neurones */
/* area without edges separator is similar to area separator with difference pixel on the picture edge have no pair in nodes in the 2nd Level and output and in that way dimension of the 2nd Level and the output is shorter by 2 in each dimension. Everything else is the same. */
neuron_type_descriptor* setup_area_without_edges_separator_descriptor()
{
neuron_type_descriptor* area_without_edges_separator;
area_without_edges_separator=MANTD((long int)1);
area_without_edges_separator->name=MAC((long int)29);
*(area_without_edges_separator->name+0)='a';
*(area_without_edges_separator->name+1)='r';
*(area_without_edges_separator->name+2)='e';
*(area_without_edges_separator->name+3)='a';
*(area_without_edges_separator->name+4)='_';
*(area_without_edges_separator->name+5)='w';
*(area_without_edges_separator->name+6)='i';
*(area_without_edges_separator->name+7)='t';
*(area_without_edges_separator->name+8)='h';
*(area_without_edges_separator->name+9)='o';
*(area_without_edges_separator->name+10)='u';
*(area_without_edges_separator->name+11)='t';
*(area_without_edges_separator->name+12)='_';
*(area_without_edges_separator->name+13)='e';
*(area_without_edges_separator->name+14)='d';
*(area_without_edges_separator->name+15)='g';
*(area_without_edges_separator->name+16)='e';
*(area_without_edges_separator->name+17)='s';
*(area_without_edges_separator->name+18)='_';
*(area_without_edges_separator->name+19)='s';
*(area_without_edges_separator->name+20)='e';
*(area_without_edges_separator->name+21)='p';
*(area_without_edges_separator->name+22)='a';
*(area_without_edges_separator->name+23)='r';
*(area_without_edges_separator->name+24)='a';
*(area_without_edges_separator->name+25)='t';
*(area_without_edges_separator->name+26)='o';
*(area_without_edges_separator->name+27)='r';
*(area_without_edges_separator->name+28)=' ';
area_without_edges_separator->number_of_Levels=2;
area_without_edges_separator->inputs_per_first_Level_node=1+8; /* means its associated input and outputs of its neighbouring nodes (8 of them) */
area_without_edges_separator->nodes_per_Level=MAI((long int)area_without_edges_separator->number_of_Levels);
*(area_without_edges_separator->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(area_without_edges_separator->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are in the 1st Level */
area_without_edges_separator->recurrence=F;
area_without_edges_separator->number_of_recurrent_connected_layers=0;
area_without_edges_separator->source=0;
area_without_edges_separator->destination=0;
area_without_edges_separator->number_of_functions_for_creating_neuron=1;
area_without_edges_separator->create_neuron=(void**)testmalloc((size_t)area_without_edges_separator->number_of_functions_for_creating_neuron*sizeof(void*));
if(area_without_edges_separator->create_neuron==0) exit_handling(19,1);
*(area_without_edges_separator->create_neuron)=create_area_without_edges_separator;
area_without_edges_separator->create_neuron_population=create_neuron_population;
area_without_edges_separator->prepare_input=preparing_area_separator_neuron_population_neuron_inputs;
area_without_edges_separator->number_linear_output_functions=1;
area_without_edges_separator->node_linear_output=(void**)testmalloc((size_t)area_without_edges_separator->number_linear_output_functions*sizeof(void*));
if(area_without_edges_separator->node_linear_output==0) exit_handling(19,2);
*(area_without_edges_separator->node_linear_output)=area_without_edges_separator_all_Levels;
area_without_edges_separator->number_of_node_output_functions=5;
area_without_edges_separator->node_output=(void**)testmalloc((size_t)area_without_edges_separator->number_of_node_output_functions*sizeof(void*));
if(area_without_edges_separator->node_output==0) exit_handling(19,3);
*(area_without_edges_separator->node_output+0)=unchanged_linear_node_output;
*(area_without_edges_separator->node_output+1)=exp_node_output;
*(area_without_edges_separator->node_output+2)=exp_positive_node_output;
*(area_without_edges_separator->node_output+3)=tgh_node_output;
*(area_without_edges_separator->node_output+4)=treasureholded_node_output;
area_without_edges_separator->node_output_derivation=(void**)testmalloc((size_t)area_without_edges_separator->number_of_node_output_functions*sizeof(void*));
if(area_without_edges_separator->node_output_derivation==0) exit_handling(19,4);
*(area_without_edges_separator->node_output_derivation+0)=unchanged_linear_node_output_derivation;
*(area_without_edges_separator->node_output_derivation+1)=exp_node_output_derivation;
*(area_without_edges_separator->node_output_derivation+2)=exp_positive_node_output_derivation;
*(area_without_edges_separator->node_output_derivation+3)=tgh_node_output_derivation;
*(area_without_edges_separator->node_output_derivation+4)=treasureholded_node_output_derivation;
area_without_edges_separator->number_of_firing_functions=1;
area_without_edges_separator->firing_neuron=(void**)testmalloc((size_t)area_without_edges_separator->number_of_firing_functions*sizeof(void*));
if(area_without_edges_separator->firing_neuron==0) exit_handling(19,5);
*(area_without_edges_separator->firing_neuron)=firing_area_without_edges_separator;
area_without_edges_separator->number_of_learning_algorithms=1; /* this type of neuron is not expected/proposed to learn */
area_without_edges_separator->create_learning_algorithm=(void**)testmalloc((size_t)area_without_edges_separator->number_of_learning_algorithms*sizeof(void*));
if(area_without_edges_separator->create_learning_algorithm==0) exit_handling(19,6);
*(area_without_edges_separator->create_learning_algorithm)=BP_AS_without_learning_algorithm_setup; /* this type of neuron is not expected/proposed to learn */
return(area_without_edges_separator);
} /* ; */
/* setting up FCNN_2L descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_descriptor() sets up neuron_type_descriptor for FCNN_2L (Fully Connected Neural Network with 2 Layers) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_descriptor()
{
neuron_type_descriptor* FCNN_2L;
FCNN_2L=MANTD((long int)1);
FCNN_2L->name=MAC((long int)37);
*(FCNN_2L->name+0)='F';
*(FCNN_2L->name+1)='C';
*(FCNN_2L->name+2)='N';
*(FCNN_2L->name+3)='N';
*(FCNN_2L->name+4)='_';
*(FCNN_2L->name+5)='2';
*(FCNN_2L->name+6)='L';
*(FCNN_2L->name+7)='(';
*(FCNN_2L->name+8)='F';
*(FCNN_2L->name+9)='u';
*(FCNN_2L->name+10)='l';
*(FCNN_2L->name+11)='l';
*(FCNN_2L->name+12)='y';
*(FCNN_2L->name+13)='_';
*(FCNN_2L->name+14)='C';
*(FCNN_2L->name+15)='o';
*(FCNN_2L->name+16)='n';
*(FCNN_2L->name+17)='n';
*(FCNN_2L->name+18)='e';
*(FCNN_2L->name+19)='c';
*(FCNN_2L->name+20)='t';
*(FCNN_2L->name+21)='e';
*(FCNN_2L->name+22)='d';
*(FCNN_2L->name+23)='_';
*(FCNN_2L->name+24)='N';
*(FCNN_2L->name+25)='N';
*(FCNN_2L->name+26)='_';
*(FCNN_2L->name+27)='2';
*(FCNN_2L->name+28)='_';
*(FCNN_2L->name+29)='L';
*(FCNN_2L->name+30)='a';
*(FCNN_2L->name+31)='y';
*(FCNN_2L->name+32)='e';
*(FCNN_2L->name+33)='r';
*(FCNN_2L->name+34)='s';
*(FCNN_2L->name+35)=')';
*(FCNN_2L->name+36)=' ';
FCNN_2L->number_of_Levels=2;
FCNN_2L->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_2L->nodes_per_Level=MAI((long int)FCNN_2L->number_of_Levels);
*(FCNN_2L->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L->recurrence=F;
FCNN_2L->number_of_recurrent_connected_layers=0;
FCNN_2L->source=0;
FCNN_2L->destination=0;
FCNN_2L->number_of_functions_for_creating_neuron=1;
FCNN_2L->create_neuron=(void**)testmalloc((size_t)FCNN_2L->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L->create_neuron==0) exit_handling(24,1);
*(FCNN_2L->create_neuron+0)=create_FCNN_2L;
FCNN_2L->create_neuron_population=create_neuron_population;
FCNN_2L->prepare_input=0;
FCNN_2L->number_linear_output_functions=4;
FCNN_2L->node_linear_output=(void**)testmalloc((size_t)FCNN_2L->number_linear_output_functions*sizeof(void*));
if(FCNN_2L->node_linear_output==0) exit_handling(24,2);
*(FCNN_2L->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L->node_linear_output+2)=highest_weighted_input;
*(FCNN_2L->node_linear_output+3)=RBF_exp;
FCNN_2L->number_of_node_output_functions=4;
FCNN_2L->node_output=(void**)testmalloc((size_t)FCNN_2L->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L->node_output==0) exit_handling(24,3);
*(FCNN_2L->node_output+0)=exp_node_output;
*(FCNN_2L->node_output+1)=exp_positive_node_output;
*(FCNN_2L->node_output+2)=treasureholded_node_output;
*(FCNN_2L->node_output+3)=unchanged_linear_node_output;
FCNN_2L->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L->node_output_derivation==0) exit_handling(24,4);
*(FCNN_2L->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L->number_of_firing_functions=1;
FCNN_2L->firing_neuron=(void**)testmalloc((size_t)FCNN_2L->number_of_firing_functions*sizeof(void*));
if(FCNN_2L->firing_neuron==0) exit_handling(24,5);
*(FCNN_2L->firing_neuron)=firing_standard_neuron;
FCNN_2L->number_of_learning_algorithms=3;
FCNN_2L->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L->create_learning_algorithm==0) exit_handling(24,6);
*(FCNN_2L->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_2L->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_2L);
} /* ; */
/* setting up FCNN_3L descriptor */
/* neuron_type_descriptor* setup_FCNN_3L_descriptor() sets up neuron_type_descriptor for FCNN_3L (Fully Connected Neural Network with 3 Layers) class of neurones */
neuron_type_descriptor* setup_FCNN_3L_descriptor()
{
neuron_type_descriptor* FCNN_3L;
FCNN_3L=MANTD((long int)1);
FCNN_3L->name=MAC((long int)37);
*(FCNN_3L->name+0)='F';
*(FCNN_3L->name+1)='C';
*(FCNN_3L->name+2)='N';
*(FCNN_3L->name+3)='N';
*(FCNN_3L->name+4)='_';
*(FCNN_3L->name+5)='3';
*(FCNN_3L->name+6)='L';
*(FCNN_3L->name+7)='(';
*(FCNN_3L->name+8)='F';
*(FCNN_3L->name+9)='u';
*(FCNN_3L->name+10)='l';
*(FCNN_3L->name+11)='l';
*(FCNN_3L->name+12)='y';
*(FCNN_3L->name+13)='_';
*(FCNN_3L->name+14)='C';
*(FCNN_3L->name+15)='o';
*(FCNN_3L->name+16)='n';
*(FCNN_3L->name+17)='n';
*(FCNN_3L->name+18)='e';
*(FCNN_3L->name+19)='c';
*(FCNN_3L->name+20)='t';
*(FCNN_3L->name+21)='e';
*(FCNN_3L->name+22)='d';
*(FCNN_3L->name+23)='_';
*(FCNN_3L->name+24)='N';
*(FCNN_3L->name+25)='N';
*(FCNN_3L->name+26)='_';
*(FCNN_3L->name+27)='3';
*(FCNN_3L->name+28)='_';
*(FCNN_3L->name+29)='L';
*(FCNN_3L->name+30)='a';
*(FCNN_3L->name+31)='y';
*(FCNN_3L->name+32)='e';
*(FCNN_3L->name+33)='r';
*(FCNN_3L->name+34)='s';
*(FCNN_3L->name+35)=')';
*(FCNN_3L->name+36)=' ';
FCNN_3L->number_of_Levels=3;
FCNN_3L->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_3L->nodes_per_Level=MAI((long int)FCNN_3L->number_of_Levels);
*(FCNN_3L->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_3L->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
*(FCNN_3L->nodes_per_Level+2)=0; /* means there is the same number of nodes in the 3rd Level as there are inputs */
FCNN_3L->recurrence=F;
FCNN_3L->number_of_recurrent_connected_layers=0;
FCNN_3L->source=0;
FCNN_3L->destination=0;
FCNN_3L->number_of_functions_for_creating_neuron=1;
FCNN_3L->create_neuron=(void**)testmalloc((size_t)FCNN_3L->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_3L->create_neuron==0) exit_handling(25,1);
*(FCNN_3L->create_neuron+0)=create_FCNN_3L;
FCNN_3L->create_neuron_population=create_neuron_population;
FCNN_3L->prepare_input=0;
FCNN_3L->number_linear_output_functions=4;
FCNN_3L->node_linear_output=(void**)testmalloc((size_t)FCNN_3L->number_linear_output_functions*sizeof(void*));
if(FCNN_3L->node_linear_output==0) exit_handling(25,2);
*(FCNN_3L->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_3L->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_3L->node_linear_output+2)=highest_weighted_input;
*(FCNN_3L->node_linear_output+3)=RBF_exp;
FCNN_3L->number_of_node_output_functions=4;
FCNN_3L->node_output=(void**)testmalloc((size_t)FCNN_3L->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L->node_output==0) exit_handling(25,3);
*(FCNN_3L->node_output+0)=exp_node_output;
*(FCNN_3L->node_output+1)=exp_positive_node_output;
*(FCNN_3L->node_output+2)=treasureholded_node_output;
*(FCNN_3L->node_output+3)=unchanged_linear_node_output;
FCNN_3L->node_output_derivation=(void**)testmalloc((size_t)FCNN_3L->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L->node_output_derivation==0) exit_handling(25,4);
*(FCNN_3L->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_3L->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_3L->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_3L->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_3L->number_of_firing_functions=1;
FCNN_3L->firing_neuron=(void**)testmalloc((size_t)FCNN_3L->number_of_firing_functions*sizeof(void*));
if(FCNN_3L->firing_neuron==0) exit_handling(25,5);
*(FCNN_3L->firing_neuron)=firing_standard_neuron;
FCNN_3L->number_of_learning_algorithms=3;
FCNN_3L->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_3L->number_of_learning_algorithms*sizeof(void*));
if(FCNN_3L->create_learning_algorithm==0) exit_handling(25,6);
*(FCNN_3L->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_3L->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_3L->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_3L);
} /* ; */
/* setting up FCNN_4L descriptor */
/* neuron_type_descriptor* setup_FCNN_4L_descriptor() sets up neuron_type_descriptor for FCNN_4L (Fully Connected Neural Network with 4 Layers) class of neurones */
neuron_type_descriptor* setup_FCNN_4L_descriptor()
{
neuron_type_descriptor* FCNN_4L;
FCNN_4L=MANTD((long int)1);
FCNN_4L->name=MAC((long int)37);
*(FCNN_4L->name+0)='F';
*(FCNN_4L->name+1)='C';
*(FCNN_4L->name+2)='N';
*(FCNN_4L->name+3)='N';
*(FCNN_4L->name+4)='_';
*(FCNN_4L->name+5)='4';
*(FCNN_4L->name+6)='L';
*(FCNN_4L->name+7)='(';
*(FCNN_4L->name+8)='F';
*(FCNN_4L->name+9)='u';
*(FCNN_4L->name+10)='l';
*(FCNN_4L->name+11)='l';
*(FCNN_4L->name+12)='y';
*(FCNN_4L->name+13)='_';
*(FCNN_4L->name+14)='C';
*(FCNN_4L->name+15)='o';
*(FCNN_4L->name+16)='n';
*(FCNN_4L->name+17)='n';
*(FCNN_4L->name+18)='e';
*(FCNN_4L->name+19)='c';
*(FCNN_4L->name+20)='t';
*(FCNN_4L->name+21)='e';
*(FCNN_4L->name+22)='d';
*(FCNN_4L->name+23)='_';
*(FCNN_4L->name+24)='N';
*(FCNN_4L->name+25)='N';
*(FCNN_4L->name+26)='_';
*(FCNN_4L->name+27)='4';
*(FCNN_4L->name+28)='_';
*(FCNN_4L->name+29)='L';
*(FCNN_4L->name+30)='a';
*(FCNN_4L->name+31)='y';
*(FCNN_4L->name+32)='e';
*(FCNN_4L->name+33)='r';
*(FCNN_4L->name+34)='s';
*(FCNN_4L->name+35)=')';
*(FCNN_4L->name+36)=' ';
FCNN_4L->number_of_Levels=4;
FCNN_4L->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_4L->nodes_per_Level=MAI((long int)FCNN_4L->number_of_Levels);
*(FCNN_4L->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_4L->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
*(FCNN_4L->nodes_per_Level+2)=0; /* means there is the same number of nodes in the 3rd Level as there are inputs */
*(FCNN_4L->nodes_per_Level+3)=0; /* means there is the same number of nodes in the 4th Level as there are inputs */
FCNN_4L->recurrence=F;
FCNN_4L->number_of_recurrent_connected_layers=0;
FCNN_4L->source=0;
FCNN_4L->destination=0;
FCNN_4L->number_of_functions_for_creating_neuron=1;
FCNN_4L->create_neuron=(void**)testmalloc((size_t)FCNN_4L->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_4L->create_neuron==0) exit_handling(26,1);
*(FCNN_4L->create_neuron+0)=create_FCNN_4L;
FCNN_4L->create_neuron_population=create_neuron_population;
FCNN_4L->prepare_input=0;
FCNN_4L->number_linear_output_functions=4;
FCNN_4L->node_linear_output=(void**)testmalloc((size_t)FCNN_4L->number_linear_output_functions*sizeof(void*));
if(FCNN_4L->node_linear_output==0) exit_handling(26,2);
*(FCNN_4L->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_4L->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_4L->node_linear_output+2)=highest_weighted_input;
*(FCNN_4L->node_linear_output+3)=RBF_exp;
FCNN_4L->number_of_node_output_functions=4;
FCNN_4L->node_output=(void**)testmalloc((size_t)FCNN_4L->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L->node_output==0) exit_handling(26,3);
*(FCNN_4L->node_output+0)=exp_node_output;
*(FCNN_4L->node_output+1)=exp_positive_node_output;
*(FCNN_4L->node_output+2)=treasureholded_node_output;
*(FCNN_4L->node_output+3)=unchanged_linear_node_output;
FCNN_4L->node_output_derivation=(void**)testmalloc((size_t)FCNN_4L->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L->node_output_derivation==0) exit_handling(26,4);
*(FCNN_4L->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_4L->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_4L->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_4L->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_4L->number_of_firing_functions=1;
FCNN_4L->firing_neuron=(void**)testmalloc((size_t)FCNN_4L->number_of_firing_functions*sizeof(void*));
if(FCNN_4L->firing_neuron==0) exit_handling(26,5);
*(FCNN_4L->firing_neuron)=firing_standard_neuron;
FCNN_4L->number_of_learning_algorithms=3;
FCNN_4L->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_4L->number_of_learning_algorithms*sizeof(void*));
if(FCNN_4L->create_learning_algorithm==0) exit_handling(26,6);
*(FCNN_4L->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_4L->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_4L->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_4L);
} /* ; */
/* setting up FCNN_5L descriptor */
/* neuron_type_descriptor* setup_FCNN_5L_descriptor() sets up neuron_type_descriptor for FCNN_5L (Fully Connected Neural Network with 5 Layers) class of neurones */
neuron_type_descriptor* setup_FCNN_5L_descriptor()
{
neuron_type_descriptor* FCNN_5L;
FCNN_5L=MANTD((long int)1);
FCNN_5L->name=MAC((long int)37);
*(FCNN_5L->name+0)='F';
*(FCNN_5L->name+1)='C';
*(FCNN_5L->name+2)='N';
*(FCNN_5L->name+3)='N';
*(FCNN_5L->name+4)='_';
*(FCNN_5L->name+5)='5';
*(FCNN_5L->name+6)='L';
*(FCNN_5L->name+7)='(';
*(FCNN_5L->name+8)='F';
*(FCNN_5L->name+9)='u';
*(FCNN_5L->name+10)='l';
*(FCNN_5L->name+11)='l';
*(FCNN_5L->name+12)='y';
*(FCNN_5L->name+13)='_';
*(FCNN_5L->name+14)='C';
*(FCNN_5L->name+15)='o';
*(FCNN_5L->name+16)='n';
*(FCNN_5L->name+17)='n';
*(FCNN_5L->name+18)='e';
*(FCNN_5L->name+19)='c';
*(FCNN_5L->name+20)='t';
*(FCNN_5L->name+21)='e';
*(FCNN_5L->name+22)='d';
*(FCNN_5L->name+23)='_';
*(FCNN_5L->name+24)='N';
*(FCNN_5L->name+25)='N';
*(FCNN_5L->name+26)='_';
*(FCNN_5L->name+27)='5';
*(FCNN_5L->name+28)='_';
*(FCNN_5L->name+29)='L';
*(FCNN_5L->name+30)='a';
*(FCNN_5L->name+31)='y';
*(FCNN_5L->name+32)='e';
*(FCNN_5L->name+33)='r';
*(FCNN_5L->name+34)='s';
*(FCNN_5L->name+35)=')';
*(FCNN_5L->name+36)=' ';
FCNN_5L->number_of_Levels=5;
FCNN_5L->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_5L->nodes_per_Level=MAI((long int)FCNN_5L->number_of_Levels);
*(FCNN_5L->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_5L->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
*(FCNN_5L->nodes_per_Level+2)=0; /* means there is the same number of nodes in the 3rd Level as there are inputs */
*(FCNN_5L->nodes_per_Level+3)=0; /* means there is the same number of nodes in the 4th Level as there are inputs */
*(FCNN_5L->nodes_per_Level+4)=0; /* means there is the same number of nodes in the 5th Level as there are inputs */
FCNN_5L->recurrence=F;
FCNN_5L->number_of_recurrent_connected_layers=0;
FCNN_5L->source=0;
FCNN_5L->destination=0;
FCNN_5L->number_of_functions_for_creating_neuron=1;
FCNN_5L->create_neuron=(void**)testmalloc((size_t)FCNN_5L->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_5L->create_neuron==0) exit_handling(27,1);
*(FCNN_5L->create_neuron+0)=create_FCNN_5L;
FCNN_5L->create_neuron_population=create_neuron_population;
FCNN_5L->prepare_input=0;
FCNN_5L->number_linear_output_functions=4;
FCNN_5L->node_linear_output=(void**)testmalloc((size_t)FCNN_5L->number_linear_output_functions*sizeof(void*));
if(FCNN_5L->node_linear_output==0) exit_handling(27,2);
*(FCNN_5L->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_5L->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_5L->node_linear_output+2)=highest_weighted_input;
*(FCNN_5L->node_linear_output+3)=RBF_exp;
FCNN_5L->number_of_node_output_functions=4;
FCNN_5L->node_output=(void**)testmalloc((size_t)FCNN_5L->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L->node_output==0) exit_handling(27,3);
*(FCNN_5L->node_output+0)=exp_node_output;
*(FCNN_5L->node_output+1)=exp_positive_node_output;
*(FCNN_5L->node_output+2)=treasureholded_node_output;
*(FCNN_5L->node_output+3)=unchanged_linear_node_output;
FCNN_5L->node_output_derivation=(void**)testmalloc((size_t)FCNN_5L->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L->node_output_derivation==0) exit_handling(27,4);
*(FCNN_5L->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_5L->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_5L->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_5L->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_5L->number_of_firing_functions=1;
FCNN_5L->firing_neuron=(void**)testmalloc((size_t)FCNN_5L->number_of_firing_functions*sizeof(void*));
if(FCNN_5L->firing_neuron==0) exit_handling(27,5);
*(FCNN_5L->firing_neuron)=firing_standard_neuron;
FCNN_5L->number_of_learning_algorithms=3;
FCNN_5L->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_5L->number_of_learning_algorithms*sizeof(void*));
if(FCNN_5L->create_learning_algorithm==0) exit_handling(27,6);
*(FCNN_5L->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_5L->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_5L->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_5L);
} /* ; */
/* setting up FCNN_2L_W descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_descriptor() sets up neuron_type_descriptor for FCNN_2L_W (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_descriptor()
{
neuron_type_descriptor* FCNN_2L_W;
FCNN_2L_W=MANTD((long int)1);
FCNN_2L_W->name=MAC((long int)70);
*(FCNN_2L_W->name+0)='F';
*(FCNN_2L_W->name+1)='C';
*(FCNN_2L_W->name+2)='N';
*(FCNN_2L_W->name+3)='N';
*(FCNN_2L_W->name+4)='_';
*(FCNN_2L_W->name+5)='2';
*(FCNN_2L_W->name+6)='L';
*(FCNN_2L_W->name+7)='_';
*(FCNN_2L_W->name+8)='W';
*(FCNN_2L_W->name+9)='(';
*(FCNN_2L_W->name+10)='F';
*(FCNN_2L_W->name+11)='u';
*(FCNN_2L_W->name+12)='l';
*(FCNN_2L_W->name+13)='l';
*(FCNN_2L_W->name+14)='y';
*(FCNN_2L_W->name+15)='_';
*(FCNN_2L_W->name+16)='C';
*(FCNN_2L_W->name+17)='o';
*(FCNN_2L_W->name+18)='n';
*(FCNN_2L_W->name+19)='n';
*(FCNN_2L_W->name+20)='e';
*(FCNN_2L_W->name+21)='c';
*(FCNN_2L_W->name+22)='t';
*(FCNN_2L_W->name+23)='e';
*(FCNN_2L_W->name+24)='d';
*(FCNN_2L_W->name+25)='_';
*(FCNN_2L_W->name+26)='N';
*(FCNN_2L_W->name+27)='N';
*(FCNN_2L_W->name+28)='_';
*(FCNN_2L_W->name+29)='2';
*(FCNN_2L_W->name+30)='_';
*(FCNN_2L_W->name+31)='L';
*(FCNN_2L_W->name+32)='a';
*(FCNN_2L_W->name+33)='y';
*(FCNN_2L_W->name+34)='e';
*(FCNN_2L_W->name+35)='r';
*(FCNN_2L_W->name+36)='s';
*(FCNN_2L_W->name+37)='_';
*(FCNN_2L_W->name+38)='r';
*(FCNN_2L_W->name+39)='e';
*(FCNN_2L_W->name+40)='c';
*(FCNN_2L_W->name+41)='e';
*(FCNN_2L_W->name+42)='i';
*(FCNN_2L_W->name+43)='v';
*(FCNN_2L_W->name+44)='i';
*(FCNN_2L_W->name+45)='n';
*(FCNN_2L_W->name+46)='g';
*(FCNN_2L_W->name+47)='_';
*(FCNN_2L_W->name+48)='i';
*(FCNN_2L_W->name+49)='n';
*(FCNN_2L_W->name+50)='p';
*(FCNN_2L_W->name+51)='u';
*(FCNN_2L_W->name+52)='t';
*(FCNN_2L_W->name+53)='_';
*(FCNN_2L_W->name+54)='t';
*(FCNN_2L_W->name+55)='h';
*(FCNN_2L_W->name+56)='r';
*(FCNN_2L_W->name+57)='o';
*(FCNN_2L_W->name+58)='u';
*(FCNN_2L_W->name+59)='g';
*(FCNN_2L_W->name+60)='h';
*(FCNN_2L_W->name+61)='_';
*(FCNN_2L_W->name+62)='W';
*(FCNN_2L_W->name+63)='i';
*(FCNN_2L_W->name+64)='n';
*(FCNN_2L_W->name+65)='d';
*(FCNN_2L_W->name+66)='o';
*(FCNN_2L_W->name+67)='w';
*(FCNN_2L_W->name+68)=')';
*(FCNN_2L_W->name+69)=' ';
FCNN_2L_W->number_of_Levels=2;
FCNN_2L_W->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W->prepare_input()) */
FCNN_2L_W->nodes_per_Level=MAI((long int)FCNN_2L_W->number_of_Levels);
*(FCNN_2L_W->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W->recurrence=F;
FCNN_2L_W->number_of_recurrent_connected_layers=0;
FCNN_2L_W->source=0;
FCNN_2L_W->destination=0;
FCNN_2L_W->number_of_functions_for_creating_neuron=1;
FCNN_2L_W->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W->create_neuron==0) exit_handling(31,1);
*(FCNN_2L_W->create_neuron+0)=create_FCNN_2L;
FCNN_2L_W->create_neuron_population=create_neuron_population;
FCNN_2L_W->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W->number_linear_output_functions=4;
FCNN_2L_W->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W->node_linear_output==0) exit_handling(31,2);
*(FCNN_2L_W->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W->node_linear_output+2)=highest_weighted_input;
*(FCNN_2L_W->node_linear_output+3)=RBF_exp;
FCNN_2L_W->number_of_node_output_functions=4;
FCNN_2L_W->node_output=(void**)testmalloc((size_t)FCNN_2L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W->node_output==0) exit_handling(31,3);
*(FCNN_2L_W->node_output+0)=exp_node_output;
*(FCNN_2L_W->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W->node_output_derivation==0) exit_handling(31,4);
*(FCNN_2L_W->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W->number_of_firing_functions=1;
FCNN_2L_W->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W->firing_neuron==0) exit_handling(31,5);
*(FCNN_2L_W->firing_neuron)=firing_standard_neuron;
FCNN_2L_W->number_of_learning_algorithms=3;
FCNN_2L_W->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W->create_learning_algorithm==0) exit_handling(31,6);
*(FCNN_2L_W->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_2L_W->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_2L_W);
} /* ; */
/* setting up FCNN_3L_W descriptor */
/* neuron_type_descriptor* setup_FCNN_3L_W_descriptor() sets up neuron_type_descriptor for FCNN_3L_W (Fully Connected Neural Network with 3 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius) class of neurones */
neuron_type_descriptor* setup_FCNN_3L_W_descriptor()
{
neuron_type_descriptor* FCNN_3L_W;
FCNN_3L_W=MANTD((long int)1);
FCNN_3L_W->name=MAC((long int)70);
*(FCNN_3L_W->name+0)='F';
*(FCNN_3L_W->name+1)='C';
*(FCNN_3L_W->name+2)='N';
*(FCNN_3L_W->name+3)='N';
*(FCNN_3L_W->name+4)='_';
*(FCNN_3L_W->name+5)='3';
*(FCNN_3L_W->name+6)='L';
*(FCNN_3L_W->name+7)='_';
*(FCNN_3L_W->name+8)='W';
*(FCNN_3L_W->name+9)='(';
*(FCNN_3L_W->name+10)='F';
*(FCNN_3L_W->name+11)='u';
*(FCNN_3L_W->name+12)='l';
*(FCNN_3L_W->name+13)='l';
*(FCNN_3L_W->name+14)='y';
*(FCNN_3L_W->name+15)='_';
*(FCNN_3L_W->name+16)='C';
*(FCNN_3L_W->name+17)='o';
*(FCNN_3L_W->name+18)='n';
*(FCNN_3L_W->name+19)='n';
*(FCNN_3L_W->name+20)='e';
*(FCNN_3L_W->name+21)='c';
*(FCNN_3L_W->name+22)='t';
*(FCNN_3L_W->name+23)='e';
*(FCNN_3L_W->name+24)='d';
*(FCNN_3L_W->name+25)='_';
*(FCNN_3L_W->name+26)='N';
*(FCNN_3L_W->name+27)='N';
*(FCNN_3L_W->name+28)='_';
*(FCNN_3L_W->name+29)='3';
*(FCNN_3L_W->name+30)='_';
*(FCNN_3L_W->name+31)='L';
*(FCNN_3L_W->name+32)='a';
*(FCNN_3L_W->name+33)='y';
*(FCNN_3L_W->name+34)='e';
*(FCNN_3L_W->name+35)='r';
*(FCNN_3L_W->name+36)='s';
*(FCNN_3L_W->name+37)='_';
*(FCNN_3L_W->name+38)='r';
*(FCNN_3L_W->name+39)='e';
*(FCNN_3L_W->name+40)='c';
*(FCNN_3L_W->name+41)='e';
*(FCNN_3L_W->name+42)='i';
*(FCNN_3L_W->name+43)='v';
*(FCNN_3L_W->name+44)='i';
*(FCNN_3L_W->name+45)='n';
*(FCNN_3L_W->name+46)='g';
*(FCNN_3L_W->name+47)='_';
*(FCNN_3L_W->name+48)='i';
*(FCNN_3L_W->name+49)='n';
*(FCNN_3L_W->name+50)='p';
*(FCNN_3L_W->name+51)='u';
*(FCNN_3L_W->name+52)='t';
*(FCNN_3L_W->name+53)='_';
*(FCNN_3L_W->name+54)='t';
*(FCNN_3L_W->name+55)='h';
*(FCNN_3L_W->name+56)='r';
*(FCNN_3L_W->name+57)='o';
*(FCNN_3L_W->name+58)='u';
*(FCNN_3L_W->name+59)='g';
*(FCNN_3L_W->name+60)='h';
*(FCNN_3L_W->name+61)='_';
*(FCNN_3L_W->name+62)='W';
*(FCNN_3L_W->name+63)='i';
*(FCNN_3L_W->name+64)='n';
*(FCNN_3L_W->name+65)='d';
*(FCNN_3L_W->name+66)='o';
*(FCNN_3L_W->name+67)='w';
*(FCNN_3L_W->name+68)=')';
*(FCNN_3L_W->name+69)=' ';
FCNN_3L_W->number_of_Levels=3;
FCNN_3L_W->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_3L_W->prepare_input()) */
FCNN_3L_W->nodes_per_Level=MAI((long int)FCNN_3L_W->number_of_Levels);
*(FCNN_3L_W->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_3L_W->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
*(FCNN_3L_W->nodes_per_Level+2)=0; /* means there is the same number of nodes in the 3rd Level as there are inputs */
FCNN_3L_W->recurrence=F;
FCNN_3L_W->number_of_recurrent_connected_layers=0;
FCNN_3L_W->source=0;
FCNN_3L_W->destination=0;
FCNN_3L_W->number_of_functions_for_creating_neuron=1;
FCNN_3L_W->create_neuron=(void**)testmalloc((size_t)FCNN_3L_W->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_3L_W->create_neuron==0) exit_handling(30,1);
*(FCNN_3L_W->create_neuron+0)=create_FCNN_3L;
FCNN_3L_W->create_neuron_population=create_neuron_population;
FCNN_3L_W->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_3L_W->number_linear_output_functions=4;
FCNN_3L_W->node_linear_output=(void**)testmalloc((size_t)FCNN_3L_W->number_linear_output_functions*sizeof(void*));
if(FCNN_3L_W->node_linear_output==0) exit_handling(30,2);
*(FCNN_3L_W->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_3L_W->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_3L_W->node_linear_output+2)=highest_weighted_input;
*(FCNN_3L_W->node_linear_output+3)=RBF_exp;
FCNN_3L_W->number_of_node_output_functions=4;
FCNN_3L_W->node_output=(void**)testmalloc((size_t)FCNN_3L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L_W->node_output==0) exit_handling(30,3);
*(FCNN_3L_W->node_output+0)=exp_node_output;
*(FCNN_3L_W->node_output+1)=exp_positive_node_output;
*(FCNN_3L_W->node_output+2)=treasureholded_node_output;
*(FCNN_3L_W->node_output+3)=unchanged_linear_node_output;
FCNN_3L_W->node_output_derivation=(void**)testmalloc((size_t)FCNN_3L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L_W->node_output_derivation==0) exit_handling(30,4);
*(FCNN_3L_W->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_3L_W->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_3L_W->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_3L_W->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_3L_W->number_of_firing_functions=1;
FCNN_3L_W->firing_neuron=(void**)testmalloc((size_t)FCNN_3L_W->number_of_firing_functions*sizeof(void*));
if(FCNN_3L_W->firing_neuron==0) exit_handling(30,5);
*(FCNN_3L_W->firing_neuron)=firing_standard_neuron;
FCNN_3L_W->number_of_learning_algorithms=3;
FCNN_3L_W->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_3L_W->number_of_learning_algorithms*sizeof(void*));
if(FCNN_3L_W->create_learning_algorithm==0) exit_handling(30,6);
*(FCNN_3L_W->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_3L_W->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_3L_W->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_3L_W);
} /* ; */
/* setting up FCNN_4L_W descriptor */
/* neuron_type_descriptor* setup_FCNN_4L_W_descriptor() sets up neuron_type_descriptor for FCNN_4L_W (Fully Connected Neural Network with 4 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius) class of neurones */
neuron_type_descriptor* setup_FCNN_4L_W_descriptor()
{
neuron_type_descriptor* FCNN_4L_W;
FCNN_4L_W=MANTD((long int)1);
FCNN_4L_W->name=MAC((long int)70);
*(FCNN_4L_W->name+0)='F';
*(FCNN_4L_W->name+1)='C';
*(FCNN_4L_W->name+2)='N';
*(FCNN_4L_W->name+3)='N';
*(FCNN_4L_W->name+4)='_';
*(FCNN_4L_W->name+5)='4';
*(FCNN_4L_W->name+6)='L';
*(FCNN_4L_W->name+7)='_';
*(FCNN_4L_W->name+8)='W';
*(FCNN_4L_W->name+9)='(';
*(FCNN_4L_W->name+10)='F';
*(FCNN_4L_W->name+11)='u';
*(FCNN_4L_W->name+12)='l';
*(FCNN_4L_W->name+13)='l';
*(FCNN_4L_W->name+14)='y';
*(FCNN_4L_W->name+15)='_';
*(FCNN_4L_W->name+16)='C';
*(FCNN_4L_W->name+17)='o';
*(FCNN_4L_W->name+18)='n';
*(FCNN_4L_W->name+19)='n';
*(FCNN_4L_W->name+20)='e';
*(FCNN_4L_W->name+21)='c';
*(FCNN_4L_W->name+22)='t';
*(FCNN_4L_W->name+23)='e';
*(FCNN_4L_W->name+24)='d';
*(FCNN_4L_W->name+25)='_';
*(FCNN_4L_W->name+26)='N';
*(FCNN_4L_W->name+27)='N';
*(FCNN_4L_W->name+28)='_';
*(FCNN_4L_W->name+29)='4';
*(FCNN_4L_W->name+30)='_';
*(FCNN_4L_W->name+31)='L';
*(FCNN_4L_W->name+32)='a';
*(FCNN_4L_W->name+33)='y';
*(FCNN_4L_W->name+34)='e';
*(FCNN_4L_W->name+35)='r';
*(FCNN_4L_W->name+36)='s';
*(FCNN_4L_W->name+37)='_';
*(FCNN_4L_W->name+38)='r';
*(FCNN_4L_W->name+39)='e';
*(FCNN_4L_W->name+40)='c';
*(FCNN_4L_W->name+41)='e';
*(FCNN_4L_W->name+42)='i';
*(FCNN_4L_W->name+43)='v';
*(FCNN_4L_W->name+44)='i';
*(FCNN_4L_W->name+45)='n';
*(FCNN_4L_W->name+46)='g';
*(FCNN_4L_W->name+47)='_';
*(FCNN_4L_W->name+48)='i';
*(FCNN_4L_W->name+49)='n';
*(FCNN_4L_W->name+50)='p';
*(FCNN_4L_W->name+51)='u';
*(FCNN_4L_W->name+52)='t';
*(FCNN_4L_W->name+53)='_';
*(FCNN_4L_W->name+54)='t';
*(FCNN_4L_W->name+55)='h';
*(FCNN_4L_W->name+56)='r';
*(FCNN_4L_W->name+57)='o';
*(FCNN_4L_W->name+58)='u';
*(FCNN_4L_W->name+59)='g';
*(FCNN_4L_W->name+60)='h';
*(FCNN_4L_W->name+61)='_';
*(FCNN_4L_W->name+62)='W';
*(FCNN_4L_W->name+63)='i';
*(FCNN_4L_W->name+64)='n';
*(FCNN_4L_W->name+65)='d';
*(FCNN_4L_W->name+66)='o';
*(FCNN_4L_W->name+67)='w';
*(FCNN_4L_W->name+68)=')';
*(FCNN_4L_W->name+69)=' ';
FCNN_4L_W->number_of_Levels=4;
FCNN_4L_W->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_4L_W->prepare_input()) */
FCNN_4L_W->nodes_per_Level=MAI((long int)FCNN_4L_W->number_of_Levels);
*(FCNN_4L_W->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_4L_W->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
*(FCNN_4L_W->nodes_per_Level+2)=0; /* means there is the same number of nodes in the 3rd Level as there are inputs */
*(FCNN_4L_W->nodes_per_Level+3)=0; /* means there is the same number of nodes in the 4th Level as there are inputs */
FCNN_4L_W->recurrence=F;
FCNN_4L_W->number_of_recurrent_connected_layers=0;
FCNN_4L_W->source=0;
FCNN_4L_W->destination=0;
FCNN_4L_W->number_of_functions_for_creating_neuron=1;
FCNN_4L_W->create_neuron=(void**)testmalloc((size_t)FCNN_4L_W->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_4L_W->create_neuron==0) exit_handling(29,1);
*(FCNN_4L_W->create_neuron+0)=create_FCNN_4L;
FCNN_4L_W->create_neuron_population=create_neuron_population;
FCNN_4L_W->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_4L_W->number_linear_output_functions=4;
FCNN_4L_W->node_linear_output=(void**)testmalloc((size_t)FCNN_4L_W->number_linear_output_functions*sizeof(void*));
if(FCNN_4L_W->node_linear_output==0) exit_handling(29,2);
*(FCNN_4L_W->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_4L_W->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_4L_W->node_linear_output+2)=highest_weighted_input;
*(FCNN_4L_W->node_linear_output+3)=RBF_exp;
FCNN_4L_W->number_of_node_output_functions=4;
FCNN_4L_W->node_output=(void**)testmalloc((size_t)FCNN_4L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L_W->node_output==0) exit_handling(29,3);
*(FCNN_4L_W->node_output+0)=exp_node_output;
*(FCNN_4L_W->node_output+1)=exp_positive_node_output;
*(FCNN_4L_W->node_output+2)=treasureholded_node_output;
*(FCNN_4L_W->node_output+3)=unchanged_linear_node_output;
FCNN_4L_W->node_output_derivation=(void**)testmalloc((size_t)FCNN_4L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L_W->node_output_derivation==0) exit_handling(29,4);
*(FCNN_4L_W->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_4L_W->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_4L_W->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_4L_W->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_4L_W->number_of_firing_functions=1;
FCNN_4L_W->firing_neuron=(void**)testmalloc((size_t)FCNN_4L_W->number_of_firing_functions*sizeof(void*));
if(FCNN_4L_W->firing_neuron==0) exit_handling(29,5);
*(FCNN_4L_W->firing_neuron)=firing_standard_neuron;
FCNN_4L_W->number_of_learning_algorithms=3;
FCNN_4L_W->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_4L_W->number_of_learning_algorithms*sizeof(void*));
if(FCNN_4L_W->create_learning_algorithm==0) exit_handling(29,6);
*(FCNN_4L_W->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_4L_W->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_4L_W->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_4L_W);
} /* ; */
/* setting up FCNN_5L_W descriptor */
/* neuron_type_descriptor* setup_FCNN_5L_W_descriptor() sets up neuron_type_descriptor for FCNN_5L_W (Fully Connected Neural Network with 5 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius) class of neurones */
neuron_type_descriptor* setup_FCNN_5L_W_descriptor()
{
neuron_type_descriptor* FCNN_5L_W;
FCNN_5L_W=MANTD((long int)1);
FCNN_5L_W->name=MAC((long int)70);
*(FCNN_5L_W->name+0)='F';
*(FCNN_5L_W->name+1)='C';
*(FCNN_5L_W->name+2)='N';
*(FCNN_5L_W->name+3)='N';
*(FCNN_5L_W->name+4)='_';
*(FCNN_5L_W->name+5)='5';
*(FCNN_5L_W->name+6)='L';
*(FCNN_5L_W->name+7)='_';
*(FCNN_5L_W->name+8)='W';
*(FCNN_5L_W->name+9)='(';
*(FCNN_5L_W->name+10)='F';
*(FCNN_5L_W->name+11)='u';
*(FCNN_5L_W->name+12)='l';
*(FCNN_5L_W->name+13)='l';
*(FCNN_5L_W->name+14)='y';
*(FCNN_5L_W->name+15)='_';
*(FCNN_5L_W->name+16)='C';
*(FCNN_5L_W->name+17)='o';
*(FCNN_5L_W->name+18)='n';
*(FCNN_5L_W->name+19)='n';
*(FCNN_5L_W->name+20)='e';
*(FCNN_5L_W->name+21)='c';
*(FCNN_5L_W->name+22)='t';
*(FCNN_5L_W->name+23)='e';
*(FCNN_5L_W->name+24)='d';
*(FCNN_5L_W->name+25)='_';
*(FCNN_5L_W->name+26)='N';
*(FCNN_5L_W->name+27)='N';
*(FCNN_5L_W->name+28)='_';
*(FCNN_5L_W->name+29)='5';
*(FCNN_5L_W->name+30)='_';
*(FCNN_5L_W->name+31)='L';
*(FCNN_5L_W->name+32)='a';
*(FCNN_5L_W->name+33)='y';
*(FCNN_5L_W->name+34)='e';
*(FCNN_5L_W->name+35)='r';
*(FCNN_5L_W->name+36)='s';
*(FCNN_5L_W->name+37)='_';
*(FCNN_5L_W->name+38)='r';
*(FCNN_5L_W->name+39)='e';
*(FCNN_5L_W->name+40)='c';
*(FCNN_5L_W->name+41)='e';
*(FCNN_5L_W->name+42)='i';
*(FCNN_5L_W->name+43)='v';
*(FCNN_5L_W->name+44)='i';
*(FCNN_5L_W->name+45)='n';
*(FCNN_5L_W->name+46)='g';
*(FCNN_5L_W->name+47)='_';
*(FCNN_5L_W->name+48)='i';
*(FCNN_5L_W->name+49)='n';
*(FCNN_5L_W->name+50)='p';
*(FCNN_5L_W->name+51)='u';
*(FCNN_5L_W->name+52)='t';
*(FCNN_5L_W->name+53)='_';
*(FCNN_5L_W->name+54)='t';
*(FCNN_5L_W->name+55)='h';
*(FCNN_5L_W->name+56)='r';
*(FCNN_5L_W->name+57)='o';
*(FCNN_5L_W->name+58)='u';
*(FCNN_5L_W->name+59)='g';
*(FCNN_5L_W->name+60)='h';
*(FCNN_5L_W->name+61)='_';
*(FCNN_5L_W->name+62)='W';
*(FCNN_5L_W->name+63)='i';
*(FCNN_5L_W->name+64)='n';
*(FCNN_5L_W->name+65)='d';
*(FCNN_5L_W->name+66)='o';
*(FCNN_5L_W->name+67)='w';
*(FCNN_5L_W->name+68)=')';
*(FCNN_5L_W->name+69)=' ';
FCNN_5L_W->number_of_Levels=5;
FCNN_5L_W->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_5L_W->prepare_input()) */
FCNN_5L_W->nodes_per_Level=MAI((long int)FCNN_5L_W->number_of_Levels);
*(FCNN_5L_W->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_5L_W->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
*(FCNN_5L_W->nodes_per_Level+2)=0; /* means there is the same number of nodes in the 3rd Level as there are inputs */
*(FCNN_5L_W->nodes_per_Level+3)=0; /* means there is the same number of nodes in the 4th Level as there are inputs */
*(FCNN_5L_W->nodes_per_Level+4)=0; /* means there is the same number of nodes in the 5th Level as there are inputs */
FCNN_5L_W->recurrence=F;
FCNN_5L_W->number_of_recurrent_connected_layers=0;
FCNN_5L_W->source=0;
FCNN_5L_W->destination=0;
FCNN_5L_W->number_of_functions_for_creating_neuron=1;
FCNN_5L_W->create_neuron=(void**)testmalloc((size_t)FCNN_5L_W->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_5L_W->create_neuron==0) exit_handling(28,1);
*(FCNN_5L_W->create_neuron+0)=create_FCNN_5L;
FCNN_5L_W->create_neuron_population=create_neuron_population;
FCNN_5L_W->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_5L_W->number_linear_output_functions=4;
FCNN_5L_W->node_linear_output=(void**)testmalloc((size_t)FCNN_5L_W->number_linear_output_functions*sizeof(void*));
if(FCNN_5L_W->node_linear_output==0) exit_handling(28,2);
*(FCNN_5L_W->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_5L_W->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_5L_W->node_linear_output+2)=highest_weighted_input;
*(FCNN_5L_W->node_linear_output+3)=RBF_exp;
FCNN_5L_W->number_of_node_output_functions=4;
FCNN_5L_W->node_output=(void**)testmalloc((size_t)FCNN_5L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L_W->node_output==0) exit_handling(28,3);
*(FCNN_5L_W->node_output+0)=exp_node_output;
*(FCNN_5L_W->node_output+1)=exp_positive_node_output;
*(FCNN_5L_W->node_output+2)=treasureholded_node_output;
*(FCNN_5L_W->node_output+3)=unchanged_linear_node_output;
FCNN_5L_W->node_output_derivation=(void**)testmalloc((size_t)FCNN_5L_W->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L_W->node_output_derivation==0) exit_handling(28,4);
*(FCNN_5L_W->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_5L_W->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_5L_W->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_5L_W->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_5L_W->number_of_firing_functions=1;
FCNN_5L_W->firing_neuron=(void**)testmalloc((size_t)FCNN_5L_W->number_of_firing_functions*sizeof(void*));
if(FCNN_5L_W->firing_neuron==0) exit_handling(28,5);
*(FCNN_5L_W->firing_neuron)=firing_standard_neuron;
FCNN_5L_W->number_of_learning_algorithms=3;
FCNN_5L_W->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_5L_W->number_of_learning_algorithms*sizeof(void*));
if(FCNN_5L_W->create_learning_algorithm==0) exit_handling(28,6);
*(FCNN_5L_W->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_5L_W->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_5L_W->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_5L_W);
} /* ; */
/* setting up FCNN_2L_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out;
FCNN_2L_1out=MANTD((long int)1);
FCNN_2L_1out->name=MAC((long int)51);
*(FCNN_2L_1out->name+0)='F';
*(FCNN_2L_1out->name+1)='C';
*(FCNN_2L_1out->name+2)='N';
*(FCNN_2L_1out->name+3)='N';
*(FCNN_2L_1out->name+4)='_';
*(FCNN_2L_1out->name+5)='2';
*(FCNN_2L_1out->name+6)='L';
*(FCNN_2L_1out->name+7)='_';
*(FCNN_2L_1out->name+8)='1';
*(FCNN_2L_1out->name+9)='o';
*(FCNN_2L_1out->name+10)='u';
*(FCNN_2L_1out->name+11)='t';
*(FCNN_2L_1out->name+12)='(';
*(FCNN_2L_1out->name+13)='F';
*(FCNN_2L_1out->name+14)='u';
*(FCNN_2L_1out->name+15)='l';
*(FCNN_2L_1out->name+16)='l';
*(FCNN_2L_1out->name+17)='y';
*(FCNN_2L_1out->name+18)='_';
*(FCNN_2L_1out->name+19)='C';
*(FCNN_2L_1out->name+20)='o';
*(FCNN_2L_1out->name+21)='n';
*(FCNN_2L_1out->name+22)='n';
*(FCNN_2L_1out->name+23)='e';
*(FCNN_2L_1out->name+24)='c';
*(FCNN_2L_1out->name+25)='t';
*(FCNN_2L_1out->name+26)='e';
*(FCNN_2L_1out->name+27)='d';
*(FCNN_2L_1out->name+28)='_';
*(FCNN_2L_1out->name+29)='N';
*(FCNN_2L_1out->name+30)='N';
*(FCNN_2L_1out->name+31)='_';
*(FCNN_2L_1out->name+32)='2';
*(FCNN_2L_1out->name+33)='_';
*(FCNN_2L_1out->name+34)='L';
*(FCNN_2L_1out->name+35)='a';
*(FCNN_2L_1out->name+36)='y';
*(FCNN_2L_1out->name+37)='e';
*(FCNN_2L_1out->name+38)='r';
*(FCNN_2L_1out->name+39)='s';
*(FCNN_2L_1out->name+40)='_';
*(FCNN_2L_1out->name+41)='1';
*(FCNN_2L_1out->name+42)='_';
*(FCNN_2L_1out->name+43)='o';
*(FCNN_2L_1out->name+44)='u';
*(FCNN_2L_1out->name+45)='t';
*(FCNN_2L_1out->name+46)='p';
*(FCNN_2L_1out->name+47)='u';
*(FCNN_2L_1out->name+48)='t';
*(FCNN_2L_1out->name+49)=')';
*(FCNN_2L_1out->name+50)=' ';
FCNN_2L_1out->number_of_Levels=2;
FCNN_2L_1out->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_2L_1out->nodes_per_Level=MAI((long int)FCNN_2L_1out->number_of_Levels);
*(FCNN_2L_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out->recurrence=F;
FCNN_2L_1out->number_of_recurrent_connected_layers=0;
FCNN_2L_1out->source=0;
FCNN_2L_1out->destination=0;
FCNN_2L_1out->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out->create_neuron==0) exit_handling(32,1);
*(FCNN_2L_1out->create_neuron+0)=create_FCNN_2L_1out;
FCNN_2L_1out->create_neuron_population=create_neuron_population;
FCNN_2L_1out->prepare_input=0;
FCNN_2L_1out->number_linear_output_functions=4;
FCNN_2L_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out->node_linear_output==0) exit_handling(32,2);
*(FCNN_2L_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_2L_1out->node_linear_output+3)=RBF_exp;
FCNN_2L_1out->number_of_node_output_functions=4;
FCNN_2L_1out->node_output=(void**)testmalloc((size_t)FCNN_2L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out->node_output==0) exit_handling(32,3);
*(FCNN_2L_1out->node_output+0)=exp_node_output;
*(FCNN_2L_1out->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out->node_output_derivation==0) exit_handling(32,4);
*(FCNN_2L_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out->number_of_firing_functions=1;
FCNN_2L_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out->firing_neuron==0) exit_handling(32,5);
*(FCNN_2L_1out->firing_neuron)=firing_standard_neuron;
FCNN_2L_1out->number_of_learning_algorithms=3;
FCNN_2L_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out->create_learning_algorithm==0) exit_handling(32,6);
*(FCNN_2L_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_2L_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_2L_1out);
} /* ; */
/* setting up FCNN_3L_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_3L_1out_descriptor() sets up neuron_type_descriptor for FCNN_3L_1out (Fully Connected Neural Network with 3 Layers and only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_3L_1out_descriptor()
{
neuron_type_descriptor* FCNN_3L_1out;
FCNN_3L_1out=MANTD((long int)1);
FCNN_3L_1out->name=MAC((long int)51);
*(FCNN_3L_1out->name+0)='F';
*(FCNN_3L_1out->name+1)='C';
*(FCNN_3L_1out->name+2)='N';
*(FCNN_3L_1out->name+3)='N';
*(FCNN_3L_1out->name+4)='_';
*(FCNN_3L_1out->name+5)='3';
*(FCNN_3L_1out->name+6)='L';
*(FCNN_3L_1out->name+7)='_';
*(FCNN_3L_1out->name+8)='1';
*(FCNN_3L_1out->name+9)='o';
*(FCNN_3L_1out->name+10)='u';
*(FCNN_3L_1out->name+11)='t';
*(FCNN_3L_1out->name+12)='(';
*(FCNN_3L_1out->name+13)='F';
*(FCNN_3L_1out->name+14)='u';
*(FCNN_3L_1out->name+15)='l';
*(FCNN_3L_1out->name+16)='l';
*(FCNN_3L_1out->name+17)='y';
*(FCNN_3L_1out->name+18)='_';
*(FCNN_3L_1out->name+19)='C';
*(FCNN_3L_1out->name+20)='o';
*(FCNN_3L_1out->name+21)='n';
*(FCNN_3L_1out->name+22)='n';
*(FCNN_3L_1out->name+23)='e';
*(FCNN_3L_1out->name+24)='c';
*(FCNN_3L_1out->name+25)='t';
*(FCNN_3L_1out->name+26)='e';
*(FCNN_3L_1out->name+27)='d';
*(FCNN_3L_1out->name+28)='_';
*(FCNN_3L_1out->name+29)='N';
*(FCNN_3L_1out->name+30)='N';
*(FCNN_3L_1out->name+31)='_';
*(FCNN_3L_1out->name+32)='3';
*(FCNN_3L_1out->name+33)='_';
*(FCNN_3L_1out->name+34)='L';
*(FCNN_3L_1out->name+35)='a';
*(FCNN_3L_1out->name+36)='y';
*(FCNN_3L_1out->name+37)='e';
*(FCNN_3L_1out->name+38)='r';
*(FCNN_3L_1out->name+39)='s';
*(FCNN_3L_1out->name+40)='_';
*(FCNN_3L_1out->name+41)='1';
*(FCNN_3L_1out->name+42)='_';
*(FCNN_3L_1out->name+43)='o';
*(FCNN_3L_1out->name+44)='u';
*(FCNN_3L_1out->name+45)='t';
*(FCNN_3L_1out->name+46)='p';
*(FCNN_3L_1out->name+47)='u';
*(FCNN_3L_1out->name+48)='t';
*(FCNN_3L_1out->name+49)=')';
*(FCNN_3L_1out->name+50)=' ';
FCNN_3L_1out->number_of_Levels=3;
FCNN_3L_1out->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_3L_1out->nodes_per_Level=MAI((long int)FCNN_3L_1out->number_of_Levels);
*(FCNN_3L_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_3L_1out->nodes_per_Level+1)=-10; /* means number of nodes in the 2nd Level is arithmetic mean of numbers of corners in the first and the last layer */
*(FCNN_3L_1out->nodes_per_Level+2)=1; /* just one output = just one node in the last layer */
FCNN_3L_1out->recurrence=F;
FCNN_3L_1out->number_of_recurrent_connected_layers=0;
FCNN_3L_1out->source=0;
FCNN_3L_1out->destination=0;
FCNN_3L_1out->number_of_functions_for_creating_neuron=1;
FCNN_3L_1out->create_neuron=(void**)testmalloc((size_t)FCNN_3L_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_3L_1out->create_neuron==0) exit_handling(33,1);
*(FCNN_3L_1out->create_neuron+0)=create_FCNN_3L_1out;
FCNN_3L_1out->create_neuron_population=create_neuron_population;
FCNN_3L_1out->prepare_input=0;
FCNN_3L_1out->number_linear_output_functions=4;
FCNN_3L_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_3L_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_3L_1out->node_linear_output==0) exit_handling(33,2);
*(FCNN_3L_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_3L_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_3L_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_3L_1out->node_linear_output+3)=RBF_exp;
FCNN_3L_1out->number_of_node_output_functions=4;
FCNN_3L_1out->node_output=(void**)testmalloc((size_t)FCNN_3L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L_1out->node_output==0) exit_handling(33,3);
*(FCNN_3L_1out->node_output+0)=exp_node_output;
*(FCNN_3L_1out->node_output+1)=exp_positive_node_output;
*(FCNN_3L_1out->node_output+2)=treasureholded_node_output;
*(FCNN_3L_1out->node_output+3)=unchanged_linear_node_output;
FCNN_3L_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_3L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L_1out->node_output_derivation==0) exit_handling(33,4);
*(FCNN_3L_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_3L_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_3L_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_3L_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_3L_1out->number_of_firing_functions=1;
FCNN_3L_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_3L_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_3L_1out->firing_neuron==0) exit_handling(33,5);
*(FCNN_3L_1out->firing_neuron)=firing_standard_neuron;
FCNN_3L_1out->number_of_learning_algorithms=3;
FCNN_3L_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_3L_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_3L_1out->create_learning_algorithm==0) exit_handling(33,6);
*(FCNN_3L_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_3L_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_3L_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_3L_1out);
} /* ; */
/* setting up FCNN_4L_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_4L_1out_descriptor() sets up neuron_type_descriptor for FCNN_4L_1out (Fully Connected Neural Network with 4 Layers and only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_4L_1out_descriptor()
{
neuron_type_descriptor* FCNN_4L_1out;
FCNN_4L_1out=MANTD((long int)1);
FCNN_4L_1out->name=MAC((long int)51);
*(FCNN_4L_1out->name+0)='F';
*(FCNN_4L_1out->name+1)='C';
*(FCNN_4L_1out->name+2)='N';
*(FCNN_4L_1out->name+3)='N';
*(FCNN_4L_1out->name+4)='_';
*(FCNN_4L_1out->name+5)='4';
*(FCNN_4L_1out->name+6)='L';
*(FCNN_4L_1out->name+7)='_';
*(FCNN_4L_1out->name+8)='1';
*(FCNN_4L_1out->name+9)='o';
*(FCNN_4L_1out->name+10)='u';
*(FCNN_4L_1out->name+11)='t';
*(FCNN_4L_1out->name+12)='(';
*(FCNN_4L_1out->name+13)='F';
*(FCNN_4L_1out->name+14)='u';
*(FCNN_4L_1out->name+15)='l';
*(FCNN_4L_1out->name+16)='l';
*(FCNN_4L_1out->name+17)='y';
*(FCNN_4L_1out->name+18)='_';
*(FCNN_4L_1out->name+19)='C';
*(FCNN_4L_1out->name+20)='o';
*(FCNN_4L_1out->name+21)='n';
*(FCNN_4L_1out->name+22)='n';
*(FCNN_4L_1out->name+23)='e';
*(FCNN_4L_1out->name+24)='c';
*(FCNN_4L_1out->name+25)='t';
*(FCNN_4L_1out->name+26)='e';
*(FCNN_4L_1out->name+27)='d';
*(FCNN_4L_1out->name+28)='_';
*(FCNN_4L_1out->name+29)='N';
*(FCNN_4L_1out->name+30)='N';
*(FCNN_4L_1out->name+31)='_';
*(FCNN_4L_1out->name+32)='4';
*(FCNN_4L_1out->name+33)='_';
*(FCNN_4L_1out->name+34)='L';
*(FCNN_4L_1out->name+35)='a';
*(FCNN_4L_1out->name+36)='y';
*(FCNN_4L_1out->name+37)='e';
*(FCNN_4L_1out->name+38)='r';
*(FCNN_4L_1out->name+39)='s';
*(FCNN_4L_1out->name+40)='_';
*(FCNN_4L_1out->name+41)='1';
*(FCNN_4L_1out->name+42)='_';
*(FCNN_4L_1out->name+43)='o';
*(FCNN_4L_1out->name+44)='u';
*(FCNN_4L_1out->name+45)='t';
*(FCNN_4L_1out->name+46)='p';
*(FCNN_4L_1out->name+47)='u';
*(FCNN_4L_1out->name+48)='t';
*(FCNN_4L_1out->name+49)=')';
*(FCNN_4L_1out->name+50)=' ';
FCNN_4L_1out->number_of_Levels=4;
FCNN_4L_1out->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_4L_1out->nodes_per_Level=MAI((long int)FCNN_4L_1out->number_of_Levels);
*(FCNN_4L_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_4L_1out->nodes_per_Level+1)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_4L_1out->nodes_per_Level+2)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_4L_1out->nodes_per_Level+3)=1; /* just one output = just one node in the last layer */
FCNN_4L_1out->recurrence=F;
FCNN_4L_1out->number_of_recurrent_connected_layers=0;
FCNN_4L_1out->source=0;
FCNN_4L_1out->destination=0;
FCNN_4L_1out->number_of_functions_for_creating_neuron=1;
FCNN_4L_1out->create_neuron=(void**)testmalloc((size_t)FCNN_4L_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_4L_1out->create_neuron==0) exit_handling(34,1);
*(FCNN_4L_1out->create_neuron+0)=create_FCNN_4L_1out;
FCNN_4L_1out->create_neuron_population=create_neuron_population;
FCNN_4L_1out->prepare_input=0;
FCNN_4L_1out->number_linear_output_functions=4;
FCNN_4L_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_4L_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_4L_1out->node_linear_output==0) exit_handling(34,2);
*(FCNN_4L_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_4L_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_4L_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_4L_1out->node_linear_output+3)=RBF_exp;
FCNN_4L_1out->number_of_node_output_functions=4;
FCNN_4L_1out->node_output=(void**)testmalloc((size_t)FCNN_4L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L_1out->node_output==0) exit_handling(34,3);
*(FCNN_4L_1out->node_output+0)=exp_node_output;
*(FCNN_4L_1out->node_output+1)=exp_positive_node_output;
*(FCNN_4L_1out->node_output+2)=treasureholded_node_output;
*(FCNN_4L_1out->node_output+3)=unchanged_linear_node_output;
FCNN_4L_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_4L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L_1out->node_output_derivation==0) exit_handling(34,4);
*(FCNN_4L_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_4L_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_4L_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_4L_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_4L_1out->number_of_firing_functions=1;
FCNN_4L_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_4L_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_4L_1out->firing_neuron==0) exit_handling(34,5);
*(FCNN_4L_1out->firing_neuron)=firing_standard_neuron;
FCNN_4L_1out->number_of_learning_algorithms=3;
FCNN_4L_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_4L_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_4L_1out->create_learning_algorithm==0) exit_handling(34,6);
*(FCNN_4L_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_4L_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_4L_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_4L_1out);
} /* ; */
/* setting up FCNN_5L_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_5L_1out_descriptor() sets up neuron_type_descriptor for FCNN_5L_1out (Fully Connected Neural Network with 5 Layers and only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_5L_1out_descriptor()
{
neuron_type_descriptor* FCNN_5L_1out;
FCNN_5L_1out=MANTD((long int)1);
FCNN_5L_1out->name=MAC((long int)51);
*(FCNN_5L_1out->name+0)='F';
*(FCNN_5L_1out->name+1)='C';
*(FCNN_5L_1out->name+2)='N';
*(FCNN_5L_1out->name+3)='N';
*(FCNN_5L_1out->name+4)='_';
*(FCNN_5L_1out->name+5)='5';
*(FCNN_5L_1out->name+6)='L';
*(FCNN_5L_1out->name+7)='_';
*(FCNN_5L_1out->name+8)='1';
*(FCNN_5L_1out->name+9)='o';
*(FCNN_5L_1out->name+10)='u';
*(FCNN_5L_1out->name+11)='t';
*(FCNN_5L_1out->name+12)='(';
*(FCNN_5L_1out->name+13)='F';
*(FCNN_5L_1out->name+14)='u';
*(FCNN_5L_1out->name+15)='l';
*(FCNN_5L_1out->name+16)='l';
*(FCNN_5L_1out->name+17)='y';
*(FCNN_5L_1out->name+18)='_';
*(FCNN_5L_1out->name+19)='C';
*(FCNN_5L_1out->name+20)='o';
*(FCNN_5L_1out->name+21)='n';
*(FCNN_5L_1out->name+22)='n';
*(FCNN_5L_1out->name+23)='e';
*(FCNN_5L_1out->name+24)='c';
*(FCNN_5L_1out->name+25)='t';
*(FCNN_5L_1out->name+26)='e';
*(FCNN_5L_1out->name+27)='d';
*(FCNN_5L_1out->name+28)='_';
*(FCNN_5L_1out->name+29)='N';
*(FCNN_5L_1out->name+30)='N';
*(FCNN_5L_1out->name+31)='_';
*(FCNN_5L_1out->name+32)='5';
*(FCNN_5L_1out->name+33)='_';
*(FCNN_5L_1out->name+34)='L';
*(FCNN_5L_1out->name+35)='a';
*(FCNN_5L_1out->name+36)='y';
*(FCNN_5L_1out->name+37)='e';
*(FCNN_5L_1out->name+38)='r';
*(FCNN_5L_1out->name+39)='s';
*(FCNN_5L_1out->name+40)='_';
*(FCNN_5L_1out->name+41)='1';
*(FCNN_5L_1out->name+42)='_';
*(FCNN_5L_1out->name+43)='o';
*(FCNN_5L_1out->name+44)='u';
*(FCNN_5L_1out->name+45)='t';
*(FCNN_5L_1out->name+46)='p';
*(FCNN_5L_1out->name+47)='u';
*(FCNN_5L_1out->name+48)='t';
*(FCNN_5L_1out->name+49)=')';
*(FCNN_5L_1out->name+50)=' ';
FCNN_5L_1out->number_of_Levels=5;
FCNN_5L_1out->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_5L_1out->nodes_per_Level=MAI((long int)FCNN_5L_1out->number_of_Levels);
*(FCNN_5L_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_5L_1out->nodes_per_Level+1)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_5L_1out->nodes_per_Level+2)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_5L_1out->nodes_per_Level+3)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_5L_1out->nodes_per_Level+4)=1; /* just one output = just one node in the last layer */
FCNN_5L_1out->recurrence=F;
FCNN_5L_1out->number_of_recurrent_connected_layers=0;
FCNN_5L_1out->source=0;
FCNN_5L_1out->destination=0;
FCNN_5L_1out->number_of_functions_for_creating_neuron=1;
FCNN_5L_1out->create_neuron=(void**)testmalloc((size_t)FCNN_5L_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_5L_1out->create_neuron==0) exit_handling(35,1);
*(FCNN_5L_1out->create_neuron+0)=create_FCNN_5L_1out;
FCNN_5L_1out->create_neuron_population=create_neuron_population;
FCNN_5L_1out->prepare_input=0;
FCNN_5L_1out->number_linear_output_functions=4;
FCNN_5L_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_5L_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_5L_1out->node_linear_output==0) exit_handling(35,2);
*(FCNN_5L_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_5L_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_5L_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_5L_1out->node_linear_output+3)=RBF_exp;
FCNN_5L_1out->number_of_node_output_functions=4;
FCNN_5L_1out->node_output=(void**)testmalloc((size_t)FCNN_5L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L_1out->node_output==0) exit_handling(35,3);
*(FCNN_5L_1out->node_output+0)=exp_node_output;
*(FCNN_5L_1out->node_output+1)=exp_positive_node_output;
*(FCNN_5L_1out->node_output+2)=treasureholded_node_output;
*(FCNN_5L_1out->node_output+3)=unchanged_linear_node_output;
FCNN_5L_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_5L_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L_1out->node_output_derivation==0) exit_handling(35,4);
*(FCNN_5L_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_5L_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_5L_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_5L_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_5L_1out->number_of_firing_functions=1;
FCNN_5L_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_5L_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_5L_1out->firing_neuron==0) exit_handling(35,5);
*(FCNN_5L_1out->firing_neuron)=firing_standard_neuron;
FCNN_5L_1out->number_of_learning_algorithms=3;
FCNN_5L_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_5L_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_5L_1out->create_learning_algorithm==0) exit_handling(35,6);
*(FCNN_5L_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_5L_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_5L_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_5L_1out);
} /* ; */
/* setting up FCNN_2L_W_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out;
FCNN_2L_W_1out=MANTD((long int)1);
FCNN_2L_W_1out->name=MAC((long int)84);
*(FCNN_2L_W_1out->name+0)='F';
*(FCNN_2L_W_1out->name+1)='C';
*(FCNN_2L_W_1out->name+2)='N';
*(FCNN_2L_W_1out->name+3)='N';
*(FCNN_2L_W_1out->name+4)='_';
*(FCNN_2L_W_1out->name+5)='2';
*(FCNN_2L_W_1out->name+6)='L';
*(FCNN_2L_W_1out->name+7)='_';
*(FCNN_2L_W_1out->name+8)='W';
*(FCNN_2L_W_1out->name+9)='_';
*(FCNN_2L_W_1out->name+10)='1';
*(FCNN_2L_W_1out->name+11)='o';
*(FCNN_2L_W_1out->name+12)='u';
*(FCNN_2L_W_1out->name+13)='t';
*(FCNN_2L_W_1out->name+14)='(';
*(FCNN_2L_W_1out->name+15)='F';
*(FCNN_2L_W_1out->name+16)='u';
*(FCNN_2L_W_1out->name+17)='l';
*(FCNN_2L_W_1out->name+18)='l';
*(FCNN_2L_W_1out->name+19)='y';
*(FCNN_2L_W_1out->name+20)='_';
*(FCNN_2L_W_1out->name+21)='C';
*(FCNN_2L_W_1out->name+22)='o';
*(FCNN_2L_W_1out->name+23)='n';
*(FCNN_2L_W_1out->name+24)='n';
*(FCNN_2L_W_1out->name+25)='e';
*(FCNN_2L_W_1out->name+26)='c';
*(FCNN_2L_W_1out->name+27)='t';
*(FCNN_2L_W_1out->name+28)='e';
*(FCNN_2L_W_1out->name+29)='d';
*(FCNN_2L_W_1out->name+30)='_';
*(FCNN_2L_W_1out->name+31)='N';
*(FCNN_2L_W_1out->name+32)='N';
*(FCNN_2L_W_1out->name+33)='_';
*(FCNN_2L_W_1out->name+34)='2';
*(FCNN_2L_W_1out->name+35)='_';
*(FCNN_2L_W_1out->name+36)='L';
*(FCNN_2L_W_1out->name+37)='a';
*(FCNN_2L_W_1out->name+38)='y';
*(FCNN_2L_W_1out->name+39)='e';
*(FCNN_2L_W_1out->name+40)='r';
*(FCNN_2L_W_1out->name+41)='s';
*(FCNN_2L_W_1out->name+42)='_';
*(FCNN_2L_W_1out->name+43)='r';
*(FCNN_2L_W_1out->name+44)='e';
*(FCNN_2L_W_1out->name+45)='c';
*(FCNN_2L_W_1out->name+46)='e';
*(FCNN_2L_W_1out->name+47)='i';
*(FCNN_2L_W_1out->name+48)='v';
*(FCNN_2L_W_1out->name+49)='i';
*(FCNN_2L_W_1out->name+50)='n';
*(FCNN_2L_W_1out->name+51)='g';
*(FCNN_2L_W_1out->name+52)='_';
*(FCNN_2L_W_1out->name+53)='i';
*(FCNN_2L_W_1out->name+54)='n';
*(FCNN_2L_W_1out->name+55)='p';
*(FCNN_2L_W_1out->name+56)='u';
*(FCNN_2L_W_1out->name+57)='t';
*(FCNN_2L_W_1out->name+58)='_';
*(FCNN_2L_W_1out->name+59)='t';
*(FCNN_2L_W_1out->name+60)='h';
*(FCNN_2L_W_1out->name+61)='r';
*(FCNN_2L_W_1out->name+62)='o';
*(FCNN_2L_W_1out->name+63)='u';
*(FCNN_2L_W_1out->name+64)='g';
*(FCNN_2L_W_1out->name+65)='h';
*(FCNN_2L_W_1out->name+66)='_';
*(FCNN_2L_W_1out->name+67)='W';
*(FCNN_2L_W_1out->name+68)='i';
*(FCNN_2L_W_1out->name+69)='n';
*(FCNN_2L_W_1out->name+70)='d';
*(FCNN_2L_W_1out->name+71)='o';
*(FCNN_2L_W_1out->name+72)='w';
*(FCNN_2L_W_1out->name+73)='_';
*(FCNN_2L_W_1out->name+74)='1';
*(FCNN_2L_W_1out->name+75)='_';
*(FCNN_2L_W_1out->name+76)='o';
*(FCNN_2L_W_1out->name+77)='u';
*(FCNN_2L_W_1out->name+78)='t';
*(FCNN_2L_W_1out->name+79)='p';
*(FCNN_2L_W_1out->name+80)='u';
*(FCNN_2L_W_1out->name+81)='t';
*(FCNN_2L_W_1out->name+82)=')';
*(FCNN_2L_W_1out->name+83)=' ';
FCNN_2L_W_1out->number_of_Levels=2;
FCNN_2L_W_1out->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out->prepare_input()) */
FCNN_2L_W_1out->nodes_per_Level=MAI((long int)FCNN_2L_W_1out->number_of_Levels);
*(FCNN_2L_W_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out->recurrence=F;
FCNN_2L_W_1out->number_of_recurrent_connected_layers=0;
FCNN_2L_W_1out->source=0;
FCNN_2L_W_1out->destination=0;
FCNN_2L_W_1out->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out->create_neuron==0) exit_handling(36,1);
*(FCNN_2L_W_1out->create_neuron+0)=create_FCNN_2L_1out;
FCNN_2L_W_1out->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out->number_linear_output_functions=4;
FCNN_2L_W_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out->node_linear_output==0) exit_handling(36,2);
*(FCNN_2L_W_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_2L_W_1out->node_linear_output+3)=RBF_exp;
FCNN_2L_W_1out->number_of_node_output_functions=4;
FCNN_2L_W_1out->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out->node_output==0) exit_handling(36,3);
*(FCNN_2L_W_1out->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out->node_output_derivation==0) exit_handling(36,4);
*(FCNN_2L_W_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out->number_of_firing_functions=1;
FCNN_2L_W_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out->firing_neuron==0) exit_handling(36,5);
*(FCNN_2L_W_1out->firing_neuron)=firing_standard_neuron;
FCNN_2L_W_1out->number_of_learning_algorithms=3;
FCNN_2L_W_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out->create_learning_algorithm==0) exit_handling(36,6);
*(FCNN_2L_W_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_2L_W_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_2L_W_1out);
} /* ; */
/* setting up FCNN_3L_W_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_3L_W_1out_descriptor() sets up neuron_type_descriptor for FCNN_3L_W_1out (Fully Connected Neural Network with 3 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_3L_W_1out_descriptor()
{
neuron_type_descriptor* FCNN_3L_W_1out;
FCNN_3L_W_1out=MANTD((long int)1);
FCNN_3L_W_1out->name=MAC((long int)84);
*(FCNN_3L_W_1out->name+0)='F';
*(FCNN_3L_W_1out->name+1)='C';
*(FCNN_3L_W_1out->name+2)='N';
*(FCNN_3L_W_1out->name+3)='N';
*(FCNN_3L_W_1out->name+4)='_';
*(FCNN_3L_W_1out->name+5)='3';
*(FCNN_3L_W_1out->name+6)='L';
*(FCNN_3L_W_1out->name+7)='_';
*(FCNN_3L_W_1out->name+8)='W';
*(FCNN_3L_W_1out->name+9)='_';
*(FCNN_3L_W_1out->name+10)='1';
*(FCNN_3L_W_1out->name+11)='o';
*(FCNN_3L_W_1out->name+12)='u';
*(FCNN_3L_W_1out->name+13)='t';
*(FCNN_3L_W_1out->name+14)='(';
*(FCNN_3L_W_1out->name+15)='F';
*(FCNN_3L_W_1out->name+16)='u';
*(FCNN_3L_W_1out->name+17)='l';
*(FCNN_3L_W_1out->name+18)='l';
*(FCNN_3L_W_1out->name+19)='y';
*(FCNN_3L_W_1out->name+20)='_';
*(FCNN_3L_W_1out->name+21)='C';
*(FCNN_3L_W_1out->name+22)='o';
*(FCNN_3L_W_1out->name+23)='n';
*(FCNN_3L_W_1out->name+24)='n';
*(FCNN_3L_W_1out->name+25)='e';
*(FCNN_3L_W_1out->name+26)='c';
*(FCNN_3L_W_1out->name+27)='t';
*(FCNN_3L_W_1out->name+28)='e';
*(FCNN_3L_W_1out->name+29)='d';
*(FCNN_3L_W_1out->name+30)='_';
*(FCNN_3L_W_1out->name+31)='N';
*(FCNN_3L_W_1out->name+32)='N';
*(FCNN_3L_W_1out->name+33)='_';
*(FCNN_3L_W_1out->name+34)='3';
*(FCNN_3L_W_1out->name+35)='_';
*(FCNN_3L_W_1out->name+36)='L';
*(FCNN_3L_W_1out->name+37)='a';
*(FCNN_3L_W_1out->name+38)='y';
*(FCNN_3L_W_1out->name+39)='e';
*(FCNN_3L_W_1out->name+40)='r';
*(FCNN_3L_W_1out->name+41)='s';
*(FCNN_3L_W_1out->name+42)='_';
*(FCNN_3L_W_1out->name+43)='r';
*(FCNN_3L_W_1out->name+44)='e';
*(FCNN_3L_W_1out->name+45)='c';
*(FCNN_3L_W_1out->name+46)='e';
*(FCNN_3L_W_1out->name+47)='i';
*(FCNN_3L_W_1out->name+48)='v';
*(FCNN_3L_W_1out->name+49)='i';
*(FCNN_3L_W_1out->name+50)='n';
*(FCNN_3L_W_1out->name+51)='g';
*(FCNN_3L_W_1out->name+52)='_';
*(FCNN_3L_W_1out->name+53)='i';
*(FCNN_3L_W_1out->name+54)='n';
*(FCNN_3L_W_1out->name+55)='p';
*(FCNN_3L_W_1out->name+56)='u';
*(FCNN_3L_W_1out->name+57)='t';
*(FCNN_3L_W_1out->name+58)='_';
*(FCNN_3L_W_1out->name+59)='t';
*(FCNN_3L_W_1out->name+60)='h';
*(FCNN_3L_W_1out->name+61)='r';
*(FCNN_3L_W_1out->name+62)='o';
*(FCNN_3L_W_1out->name+63)='u';
*(FCNN_3L_W_1out->name+64)='g';
*(FCNN_3L_W_1out->name+65)='h';
*(FCNN_3L_W_1out->name+66)='_';
*(FCNN_3L_W_1out->name+67)='W';
*(FCNN_3L_W_1out->name+68)='i';
*(FCNN_3L_W_1out->name+69)='n';
*(FCNN_3L_W_1out->name+70)='d';
*(FCNN_3L_W_1out->name+71)='o';
*(FCNN_3L_W_1out->name+72)='w';
*(FCNN_3L_W_1out->name+73)='_';
*(FCNN_3L_W_1out->name+74)='1';
*(FCNN_3L_W_1out->name+75)='_';
*(FCNN_3L_W_1out->name+76)='o';
*(FCNN_3L_W_1out->name+77)='u';
*(FCNN_3L_W_1out->name+78)='t';
*(FCNN_3L_W_1out->name+79)='p';
*(FCNN_3L_W_1out->name+80)='u';
*(FCNN_3L_W_1out->name+81)='t';
*(FCNN_3L_W_1out->name+82)=')';
*(FCNN_3L_W_1out->name+83)=' ';
FCNN_3L_W_1out->number_of_Levels=3;
FCNN_3L_W_1out->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_3L_W_1out->prepare_input()) */
FCNN_3L_W_1out->nodes_per_Level=MAI((long int)FCNN_3L_W_1out->number_of_Levels);
*(FCNN_3L_W_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_3L_W_1out->nodes_per_Level+1)=-10; /* means number of nodes in the 2nd Level is arithmetic mean of numbers of corners in the first and the last layer */
*(FCNN_3L_W_1out->nodes_per_Level+2)=1; /* just one output = just one node in the last layer */
FCNN_3L_W_1out->recurrence=F;
FCNN_3L_W_1out->number_of_recurrent_connected_layers=0;
FCNN_3L_W_1out->source=0;
FCNN_3L_W_1out->destination=0;
FCNN_3L_W_1out->number_of_functions_for_creating_neuron=1;
FCNN_3L_W_1out->create_neuron=(void**)testmalloc((size_t)FCNN_3L_W_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_3L_W_1out->create_neuron==0) exit_handling(37,1);
*(FCNN_3L_W_1out->create_neuron+0)=create_FCNN_3L_1out;
FCNN_3L_W_1out->create_neuron_population=create_neuron_population;
FCNN_3L_W_1out->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_3L_W_1out->number_linear_output_functions=4;
FCNN_3L_W_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_3L_W_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_3L_W_1out->node_linear_output==0) exit_handling(37,2);
*(FCNN_3L_W_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_3L_W_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_3L_W_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_3L_W_1out->node_linear_output+3)=RBF_exp;
FCNN_3L_W_1out->number_of_node_output_functions=4;
FCNN_3L_W_1out->node_output=(void**)testmalloc((size_t)FCNN_3L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L_W_1out->node_output==0) exit_handling(37,3);
*(FCNN_3L_W_1out->node_output+0)=exp_node_output;
*(FCNN_3L_W_1out->node_output+1)=exp_positive_node_output;
*(FCNN_3L_W_1out->node_output+2)=treasureholded_node_output;
*(FCNN_3L_W_1out->node_output+3)=unchanged_linear_node_output;
FCNN_3L_W_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_3L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_3L_W_1out->node_output_derivation==0) exit_handling(37,4);
*(FCNN_3L_W_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_3L_W_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_3L_W_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_3L_W_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_3L_W_1out->number_of_firing_functions=1;
FCNN_3L_W_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_3L_W_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_3L_W_1out->firing_neuron==0) exit_handling(37,5);
*(FCNN_3L_W_1out->firing_neuron)=firing_standard_neuron;
FCNN_3L_W_1out->number_of_learning_algorithms=3;
FCNN_3L_W_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_3L_W_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_3L_W_1out->create_learning_algorithm==0) exit_handling(37,6);
*(FCNN_3L_W_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_3L_W_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_3L_W_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_3L_W_1out);
} /* ; */
/* setting up FCNN_4L_W_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_4L_W_1out_descriptor() sets up neuron_type_descriptor for FCNN_4L_W_1out (Fully Connected Neural Network with 4 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_4L_W_1out_descriptor()
{
neuron_type_descriptor* FCNN_4L_W_1out;
FCNN_4L_W_1out=MANTD((long int)1);
FCNN_4L_W_1out->name=MAC((long int)84);
*(FCNN_4L_W_1out->name+0)='F';
*(FCNN_4L_W_1out->name+1)='C';
*(FCNN_4L_W_1out->name+2)='N';
*(FCNN_4L_W_1out->name+3)='N';
*(FCNN_4L_W_1out->name+4)='_';
*(FCNN_4L_W_1out->name+5)='4';
*(FCNN_4L_W_1out->name+6)='L';
*(FCNN_4L_W_1out->name+7)='_';
*(FCNN_4L_W_1out->name+8)='W';
*(FCNN_4L_W_1out->name+9)='_';
*(FCNN_4L_W_1out->name+10)='1';
*(FCNN_4L_W_1out->name+11)='o';
*(FCNN_4L_W_1out->name+12)='u';
*(FCNN_4L_W_1out->name+13)='t';
*(FCNN_4L_W_1out->name+14)='(';
*(FCNN_4L_W_1out->name+15)='F';
*(FCNN_4L_W_1out->name+16)='u';
*(FCNN_4L_W_1out->name+17)='l';
*(FCNN_4L_W_1out->name+18)='l';
*(FCNN_4L_W_1out->name+19)='y';
*(FCNN_4L_W_1out->name+20)='_';
*(FCNN_4L_W_1out->name+21)='C';
*(FCNN_4L_W_1out->name+22)='o';
*(FCNN_4L_W_1out->name+23)='n';
*(FCNN_4L_W_1out->name+24)='n';
*(FCNN_4L_W_1out->name+25)='e';
*(FCNN_4L_W_1out->name+26)='c';
*(FCNN_4L_W_1out->name+27)='t';
*(FCNN_4L_W_1out->name+28)='e';
*(FCNN_4L_W_1out->name+29)='d';
*(FCNN_4L_W_1out->name+30)='_';
*(FCNN_4L_W_1out->name+31)='N';
*(FCNN_4L_W_1out->name+32)='N';
*(FCNN_4L_W_1out->name+33)='_';
*(FCNN_4L_W_1out->name+34)='4';
*(FCNN_4L_W_1out->name+35)='_';
*(FCNN_4L_W_1out->name+36)='L';
*(FCNN_4L_W_1out->name+37)='a';
*(FCNN_4L_W_1out->name+38)='y';
*(FCNN_4L_W_1out->name+39)='e';
*(FCNN_4L_W_1out->name+40)='r';
*(FCNN_4L_W_1out->name+41)='s';
*(FCNN_4L_W_1out->name+42)='_';
*(FCNN_4L_W_1out->name+43)='r';
*(FCNN_4L_W_1out->name+44)='e';
*(FCNN_4L_W_1out->name+45)='c';
*(FCNN_4L_W_1out->name+46)='e';
*(FCNN_4L_W_1out->name+47)='i';
*(FCNN_4L_W_1out->name+48)='v';
*(FCNN_4L_W_1out->name+49)='i';
*(FCNN_4L_W_1out->name+50)='n';
*(FCNN_4L_W_1out->name+51)='g';
*(FCNN_4L_W_1out->name+52)='_';
*(FCNN_4L_W_1out->name+53)='i';
*(FCNN_4L_W_1out->name+54)='n';
*(FCNN_4L_W_1out->name+55)='p';
*(FCNN_4L_W_1out->name+56)='u';
*(FCNN_4L_W_1out->name+57)='t';
*(FCNN_4L_W_1out->name+58)='_';
*(FCNN_4L_W_1out->name+59)='t';
*(FCNN_4L_W_1out->name+60)='h';
*(FCNN_4L_W_1out->name+61)='r';
*(FCNN_4L_W_1out->name+62)='o';
*(FCNN_4L_W_1out->name+63)='u';
*(FCNN_4L_W_1out->name+64)='g';
*(FCNN_4L_W_1out->name+65)='h';
*(FCNN_4L_W_1out->name+66)='_';
*(FCNN_4L_W_1out->name+67)='W';
*(FCNN_4L_W_1out->name+68)='i';
*(FCNN_4L_W_1out->name+69)='n';
*(FCNN_4L_W_1out->name+70)='d';
*(FCNN_4L_W_1out->name+71)='o';
*(FCNN_4L_W_1out->name+72)='w';
*(FCNN_4L_W_1out->name+73)='_';
*(FCNN_4L_W_1out->name+74)='1';
*(FCNN_4L_W_1out->name+75)='_';
*(FCNN_4L_W_1out->name+76)='o';
*(FCNN_4L_W_1out->name+77)='u';
*(FCNN_4L_W_1out->name+78)='t';
*(FCNN_4L_W_1out->name+79)='p';
*(FCNN_4L_W_1out->name+80)='u';
*(FCNN_4L_W_1out->name+81)='t';
*(FCNN_4L_W_1out->name+82)=')';
*(FCNN_4L_W_1out->name+83)=' ';
FCNN_4L_W_1out->number_of_Levels=4;
FCNN_4L_W_1out->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_4L_W_1out->prepare_input()) */
FCNN_4L_W_1out->nodes_per_Level=MAI((long int)FCNN_4L_W_1out->number_of_Levels);
*(FCNN_4L_W_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_4L_W_1out->nodes_per_Level+1)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_4L_W_1out->nodes_per_Level+2)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_4L_W_1out->nodes_per_Level+3)=1; /* just one output = just one node in the last layer */
FCNN_4L_W_1out->recurrence=F;
FCNN_4L_W_1out->number_of_recurrent_connected_layers=0;
FCNN_4L_W_1out->source=0;
FCNN_4L_W_1out->destination=0;
FCNN_4L_W_1out->number_of_functions_for_creating_neuron=1;
FCNN_4L_W_1out->create_neuron=(void**)testmalloc((size_t)FCNN_4L_W_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_4L_W_1out->create_neuron==0) exit_handling(38,1);
*(FCNN_4L_W_1out->create_neuron+0)=create_FCNN_4L_1out;
FCNN_4L_W_1out->create_neuron_population=create_neuron_population;
FCNN_4L_W_1out->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_4L_W_1out->number_linear_output_functions=4;
FCNN_4L_W_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_4L_W_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_4L_W_1out->node_linear_output==0) exit_handling(38,2);
*(FCNN_4L_W_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_4L_W_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_4L_W_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_4L_W_1out->node_linear_output+3)=RBF_exp;
FCNN_4L_W_1out->number_of_node_output_functions=4;
FCNN_4L_W_1out->node_output=(void**)testmalloc((size_t)FCNN_4L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L_W_1out->node_output==0) exit_handling(38,3);
*(FCNN_4L_W_1out->node_output+0)=exp_node_output;
*(FCNN_4L_W_1out->node_output+1)=exp_positive_node_output;
*(FCNN_4L_W_1out->node_output+2)=treasureholded_node_output;
*(FCNN_4L_W_1out->node_output+3)=unchanged_linear_node_output;
FCNN_4L_W_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_4L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_4L_W_1out->node_output_derivation==0) exit_handling(38,4);
*(FCNN_4L_W_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_4L_W_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_4L_W_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_4L_W_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_4L_W_1out->number_of_firing_functions=1;
FCNN_4L_W_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_4L_W_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_4L_W_1out->firing_neuron==0) exit_handling(38,5);
*(FCNN_4L_W_1out->firing_neuron)=firing_standard_neuron;
FCNN_4L_W_1out->number_of_learning_algorithms=3;
FCNN_4L_W_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_4L_W_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_4L_W_1out->create_learning_algorithm==0) exit_handling(38,6);
*(FCNN_4L_W_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_4L_W_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_4L_W_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_4L_W_1out);
} /* ; */
/* setting up FCNN_5L_W_1out descriptor */
/* neuron_type_descriptor* setup_FCNN_5L_W_1out_descriptor() sets up neuron_type_descriptor for FCNN_5L_W_1out (Fully Connected Neural Network with 5 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node) class of neurones */
neuron_type_descriptor* setup_FCNN_5L_W_1out_descriptor()
{
neuron_type_descriptor* FCNN_5L_W_1out;
FCNN_5L_W_1out=MANTD((long int)1);
FCNN_5L_W_1out->name=MAC((long int)84);
*(FCNN_5L_W_1out->name+0)='F';
*(FCNN_5L_W_1out->name+1)='C';
*(FCNN_5L_W_1out->name+2)='N';
*(FCNN_5L_W_1out->name+3)='N';
*(FCNN_5L_W_1out->name+4)='_';
*(FCNN_5L_W_1out->name+5)='5';
*(FCNN_5L_W_1out->name+6)='L';
*(FCNN_5L_W_1out->name+7)='_';
*(FCNN_5L_W_1out->name+8)='W';
*(FCNN_5L_W_1out->name+9)='_';
*(FCNN_5L_W_1out->name+10)='1';
*(FCNN_5L_W_1out->name+11)='o';
*(FCNN_5L_W_1out->name+12)='u';
*(FCNN_5L_W_1out->name+13)='t';
*(FCNN_5L_W_1out->name+14)='(';
*(FCNN_5L_W_1out->name+15)='F';
*(FCNN_5L_W_1out->name+16)='u';
*(FCNN_5L_W_1out->name+17)='l';
*(FCNN_5L_W_1out->name+18)='l';
*(FCNN_5L_W_1out->name+19)='y';
*(FCNN_5L_W_1out->name+20)='_';
*(FCNN_5L_W_1out->name+21)='C';
*(FCNN_5L_W_1out->name+22)='o';
*(FCNN_5L_W_1out->name+23)='n';
*(FCNN_5L_W_1out->name+24)='n';
*(FCNN_5L_W_1out->name+25)='e';
*(FCNN_5L_W_1out->name+26)='c';
*(FCNN_5L_W_1out->name+27)='t';
*(FCNN_5L_W_1out->name+28)='e';
*(FCNN_5L_W_1out->name+29)='d';
*(FCNN_5L_W_1out->name+30)='_';
*(FCNN_5L_W_1out->name+31)='N';
*(FCNN_5L_W_1out->name+32)='N';
*(FCNN_5L_W_1out->name+33)='_';
*(FCNN_5L_W_1out->name+34)='5';
*(FCNN_5L_W_1out->name+35)='_';
*(FCNN_5L_W_1out->name+36)='L';
*(FCNN_5L_W_1out->name+37)='a';
*(FCNN_5L_W_1out->name+38)='y';
*(FCNN_5L_W_1out->name+39)='e';
*(FCNN_5L_W_1out->name+40)='r';
*(FCNN_5L_W_1out->name+41)='s';
*(FCNN_5L_W_1out->name+42)='_';
*(FCNN_5L_W_1out->name+43)='r';
*(FCNN_5L_W_1out->name+44)='e';
*(FCNN_5L_W_1out->name+45)='c';
*(FCNN_5L_W_1out->name+46)='e';
*(FCNN_5L_W_1out->name+47)='i';
*(FCNN_5L_W_1out->name+48)='v';
*(FCNN_5L_W_1out->name+49)='i';
*(FCNN_5L_W_1out->name+50)='n';
*(FCNN_5L_W_1out->name+51)='g';
*(FCNN_5L_W_1out->name+52)='_';
*(FCNN_5L_W_1out->name+53)='i';
*(FCNN_5L_W_1out->name+54)='n';
*(FCNN_5L_W_1out->name+55)='p';
*(FCNN_5L_W_1out->name+56)='u';
*(FCNN_5L_W_1out->name+57)='t';
*(FCNN_5L_W_1out->name+58)='_';
*(FCNN_5L_W_1out->name+59)='t';
*(FCNN_5L_W_1out->name+60)='h';
*(FCNN_5L_W_1out->name+61)='r';
*(FCNN_5L_W_1out->name+62)='o';
*(FCNN_5L_W_1out->name+63)='u';
*(FCNN_5L_W_1out->name+64)='g';
*(FCNN_5L_W_1out->name+65)='h';
*(FCNN_5L_W_1out->name+66)='_';
*(FCNN_5L_W_1out->name+67)='W';
*(FCNN_5L_W_1out->name+68)='i';
*(FCNN_5L_W_1out->name+69)='n';
*(FCNN_5L_W_1out->name+70)='d';
*(FCNN_5L_W_1out->name+71)='o';
*(FCNN_5L_W_1out->name+72)='w';
*(FCNN_5L_W_1out->name+73)='_';
*(FCNN_5L_W_1out->name+74)='1';
*(FCNN_5L_W_1out->name+75)='_';
*(FCNN_5L_W_1out->name+76)='o';
*(FCNN_5L_W_1out->name+77)='u';
*(FCNN_5L_W_1out->name+78)='t';
*(FCNN_5L_W_1out->name+79)='p';
*(FCNN_5L_W_1out->name+80)='u';
*(FCNN_5L_W_1out->name+81)='t';
*(FCNN_5L_W_1out->name+82)=')';
*(FCNN_5L_W_1out->name+83)=' ';
FCNN_5L_W_1out->number_of_Levels=5;
FCNN_5L_W_1out->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_5L_W_1out->prepare_input()) */
FCNN_5L_W_1out->nodes_per_Level=MAI((long int)FCNN_5L_W_1out->number_of_Levels);
*(FCNN_5L_W_1out->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_5L_W_1out->nodes_per_Level+1)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_5L_W_1out->nodes_per_Level+2)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_5L_W_1out->nodes_per_Level+3)=-11; /* means number of nodes is linearly decreasing from the 1st layer toward the last one */
*(FCNN_5L_W_1out->nodes_per_Level+4)=1; /* just one output = just one node in the last layer */
FCNN_5L_W_1out->recurrence=F;
FCNN_5L_W_1out->number_of_recurrent_connected_layers=0;
FCNN_5L_W_1out->source=0;
FCNN_5L_W_1out->destination=0;
FCNN_5L_W_1out->number_of_functions_for_creating_neuron=1;
FCNN_5L_W_1out->create_neuron=(void**)testmalloc((size_t)FCNN_5L_W_1out->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_5L_W_1out->create_neuron==0) exit_handling(39,1);
*(FCNN_5L_W_1out->create_neuron+0)=create_FCNN_5L_1out;
FCNN_5L_W_1out->create_neuron_population=create_neuron_population;
FCNN_5L_W_1out->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_5L_W_1out->number_linear_output_functions=4;
FCNN_5L_W_1out->node_linear_output=(void**)testmalloc((size_t)FCNN_5L_W_1out->number_linear_output_functions*sizeof(void*));
if(FCNN_5L_W_1out->node_linear_output==0) exit_handling(39,2);
*(FCNN_5L_W_1out->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_5L_W_1out->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_5L_W_1out->node_linear_output+2)=highest_weighted_input;
*(FCNN_5L_W_1out->node_linear_output+3)=RBF_exp;
FCNN_5L_W_1out->number_of_node_output_functions=4;
FCNN_5L_W_1out->node_output=(void**)testmalloc((size_t)FCNN_5L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L_W_1out->node_output==0) exit_handling(39,3);
*(FCNN_5L_W_1out->node_output+0)=exp_node_output;
*(FCNN_5L_W_1out->node_output+1)=exp_positive_node_output;
*(FCNN_5L_W_1out->node_output+2)=treasureholded_node_output;
*(FCNN_5L_W_1out->node_output+3)=unchanged_linear_node_output;
FCNN_5L_W_1out->node_output_derivation=(void**)testmalloc((size_t)FCNN_5L_W_1out->number_of_node_output_functions*sizeof(void*));
if(FCNN_5L_W_1out->node_output_derivation==0) exit_handling(39,4);
*(FCNN_5L_W_1out->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_5L_W_1out->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_5L_W_1out->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_5L_W_1out->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_5L_W_1out->number_of_firing_functions=1;
FCNN_5L_W_1out->firing_neuron=(void**)testmalloc((size_t)FCNN_5L_W_1out->number_of_firing_functions*sizeof(void*));
if(FCNN_5L_W_1out->firing_neuron==0) exit_handling(39,5);
*(FCNN_5L_W_1out->firing_neuron)=firing_standard_neuron;
FCNN_5L_W_1out->number_of_learning_algorithms=3;
FCNN_5L_W_1out->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_5L_W_1out->number_of_learning_algorithms*sizeof(void*));
if(FCNN_5L_W_1out->create_learning_algorithm==0) exit_handling(39,6);
*(FCNN_5L_W_1out->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_5L_W_1out->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(FCNN_5L_W_1out->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(FCNN_5L_W_1out);
} /* ; */
/* setting up FCNN_2L_FBALL_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_11 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_11;
FCNN_2L_FBALL_11=MANTD((long int)1);
FCNN_2L_FBALL_11->name=MAC((long int)59);
*(FCNN_2L_FBALL_11->name+0)='F';
*(FCNN_2L_FBALL_11->name+1)='C';
*(FCNN_2L_FBALL_11->name+2)='N';
*(FCNN_2L_FBALL_11->name+3)='N';
*(FCNN_2L_FBALL_11->name+4)='_';
*(FCNN_2L_FBALL_11->name+5)='2';
*(FCNN_2L_FBALL_11->name+6)='L';
*(FCNN_2L_FBALL_11->name+7)='_';
*(FCNN_2L_FBALL_11->name+8)='F';
*(FCNN_2L_FBALL_11->name+9)='B';
*(FCNN_2L_FBALL_11->name+10)='A';
*(FCNN_2L_FBALL_11->name+11)='L';
*(FCNN_2L_FBALL_11->name+12)='L';
*(FCNN_2L_FBALL_11->name+13)='_';
*(FCNN_2L_FBALL_11->name+14)='1';
*(FCNN_2L_FBALL_11->name+15)='1';
*(FCNN_2L_FBALL_11->name+16)='(';
*(FCNN_2L_FBALL_11->name+17)='F';
*(FCNN_2L_FBALL_11->name+18)='u';
*(FCNN_2L_FBALL_11->name+19)='l';
*(FCNN_2L_FBALL_11->name+20)='l';
*(FCNN_2L_FBALL_11->name+21)='y';
*(FCNN_2L_FBALL_11->name+22)='_';
*(FCNN_2L_FBALL_11->name+23)='C';
*(FCNN_2L_FBALL_11->name+24)='o';
*(FCNN_2L_FBALL_11->name+25)='n';
*(FCNN_2L_FBALL_11->name+26)='n';
*(FCNN_2L_FBALL_11->name+27)='e';
*(FCNN_2L_FBALL_11->name+28)='c';
*(FCNN_2L_FBALL_11->name+29)='t';
*(FCNN_2L_FBALL_11->name+30)='e';
*(FCNN_2L_FBALL_11->name+31)='d';
*(FCNN_2L_FBALL_11->name+32)='_';
*(FCNN_2L_FBALL_11->name+33)='N';
*(FCNN_2L_FBALL_11->name+34)='N';
*(FCNN_2L_FBALL_11->name+35)='_';
*(FCNN_2L_FBALL_11->name+36)='2';
*(FCNN_2L_FBALL_11->name+37)='_';
*(FCNN_2L_FBALL_11->name+38)='L';
*(FCNN_2L_FBALL_11->name+39)='a';
*(FCNN_2L_FBALL_11->name+40)='y';
*(FCNN_2L_FBALL_11->name+41)='e';
*(FCNN_2L_FBALL_11->name+42)='r';
*(FCNN_2L_FBALL_11->name+43)='s';
*(FCNN_2L_FBALL_11->name+44)='_';
*(FCNN_2L_FBALL_11->name+45)='f';
*(FCNN_2L_FBALL_11->name+46)='e';
*(FCNN_2L_FBALL_11->name+47)='e';
*(FCNN_2L_FBALL_11->name+48)='d';
*(FCNN_2L_FBALL_11->name+49)='b';
*(FCNN_2L_FBALL_11->name+50)='a';
*(FCNN_2L_FBALL_11->name+51)='c';
*(FCNN_2L_FBALL_11->name+52)='k';
*(FCNN_2L_FBALL_11->name+53)='_';
*(FCNN_2L_FBALL_11->name+54)='1';
*(FCNN_2L_FBALL_11->name+55)='>';
*(FCNN_2L_FBALL_11->name+56)='1';
*(FCNN_2L_FBALL_11->name+57)=')';
*(FCNN_2L_FBALL_11->name+58)=' ';
FCNN_2L_FBALL_11->number_of_Levels=2;
FCNN_2L_FBALL_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FBALL_11->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_11->number_of_Levels);
*(FCNN_2L_FBALL_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_11->recurrence=T;
FCNN_2L_FBALL_11->number_of_recurrent_connected_layers=1;
FCNN_2L_FBALL_11->source=MAI((long int)FCNN_2L_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_11->source+0)=1;
FCNN_2L_FBALL_11->destination=MAI((long int)FCNN_2L_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_11->destination+0)=1;
FCNN_2L_FBALL_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_11->create_neuron==0) exit_handling(40,1);
*(FCNN_2L_FBALL_11->create_neuron+0)=create_FCNN_2L_FBALL_11;
FCNN_2L_FBALL_11->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_11->prepare_input=0;
FCNN_2L_FBALL_11->number_linear_output_functions=3;
FCNN_2L_FBALL_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_11->node_linear_output==0) exit_handling(40,2);
*(FCNN_2L_FBALL_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_11->number_of_node_output_functions=4;
FCNN_2L_FBALL_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_11->node_output==0) exit_handling(40,3);
*(FCNN_2L_FBALL_11->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_11->node_output_derivation==0) exit_handling(40,4);
*(FCNN_2L_FBALL_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_11->number_of_firing_functions=2;
FCNN_2L_FBALL_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_11->firing_neuron==0) exit_handling(40,5);
*(FCNN_2L_FBALL_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FBALL_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FBALL_11->number_of_learning_algorithms=2;
FCNN_2L_FBALL_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_11->create_learning_algorithm==0) exit_handling(40,6);
*(FCNN_2L_FBALL_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_11);
} /* ; */
/* setting up FCNN_2L_FBALL_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_22 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_22;
FCNN_2L_FBALL_22=MANTD((long int)1);
FCNN_2L_FBALL_22->name=MAC((long int)59);
*(FCNN_2L_FBALL_22->name+0)='F';
*(FCNN_2L_FBALL_22->name+1)='C';
*(FCNN_2L_FBALL_22->name+2)='N';
*(FCNN_2L_FBALL_22->name+3)='N';
*(FCNN_2L_FBALL_22->name+4)='_';
*(FCNN_2L_FBALL_22->name+5)='2';
*(FCNN_2L_FBALL_22->name+6)='L';
*(FCNN_2L_FBALL_22->name+7)='_';
*(FCNN_2L_FBALL_22->name+8)='F';
*(FCNN_2L_FBALL_22->name+9)='B';
*(FCNN_2L_FBALL_22->name+10)='A';
*(FCNN_2L_FBALL_22->name+11)='L';
*(FCNN_2L_FBALL_22->name+12)='L';
*(FCNN_2L_FBALL_22->name+13)='_';
*(FCNN_2L_FBALL_22->name+14)='2';
*(FCNN_2L_FBALL_22->name+15)='2';
*(FCNN_2L_FBALL_22->name+16)='(';
*(FCNN_2L_FBALL_22->name+17)='F';
*(FCNN_2L_FBALL_22->name+18)='u';
*(FCNN_2L_FBALL_22->name+19)='l';
*(FCNN_2L_FBALL_22->name+20)='l';
*(FCNN_2L_FBALL_22->name+21)='y';
*(FCNN_2L_FBALL_22->name+22)='_';
*(FCNN_2L_FBALL_22->name+23)='C';
*(FCNN_2L_FBALL_22->name+24)='o';
*(FCNN_2L_FBALL_22->name+25)='n';
*(FCNN_2L_FBALL_22->name+26)='n';
*(FCNN_2L_FBALL_22->name+27)='e';
*(FCNN_2L_FBALL_22->name+28)='c';
*(FCNN_2L_FBALL_22->name+29)='t';
*(FCNN_2L_FBALL_22->name+30)='e';
*(FCNN_2L_FBALL_22->name+31)='d';
*(FCNN_2L_FBALL_22->name+32)='_';
*(FCNN_2L_FBALL_22->name+33)='N';
*(FCNN_2L_FBALL_22->name+34)='N';
*(FCNN_2L_FBALL_22->name+35)='_';
*(FCNN_2L_FBALL_22->name+36)='2';
*(FCNN_2L_FBALL_22->name+37)='_';
*(FCNN_2L_FBALL_22->name+38)='L';
*(FCNN_2L_FBALL_22->name+39)='a';
*(FCNN_2L_FBALL_22->name+40)='y';
*(FCNN_2L_FBALL_22->name+41)='e';
*(FCNN_2L_FBALL_22->name+42)='r';
*(FCNN_2L_FBALL_22->name+43)='s';
*(FCNN_2L_FBALL_22->name+44)='_';
*(FCNN_2L_FBALL_22->name+45)='f';
*(FCNN_2L_FBALL_22->name+46)='e';
*(FCNN_2L_FBALL_22->name+47)='e';
*(FCNN_2L_FBALL_22->name+48)='d';
*(FCNN_2L_FBALL_22->name+49)='b';
*(FCNN_2L_FBALL_22->name+50)='a';
*(FCNN_2L_FBALL_22->name+51)='c';
*(FCNN_2L_FBALL_22->name+52)='k';
*(FCNN_2L_FBALL_22->name+53)='_';
*(FCNN_2L_FBALL_22->name+54)='2';
*(FCNN_2L_FBALL_22->name+55)='>';
*(FCNN_2L_FBALL_22->name+56)='2';
*(FCNN_2L_FBALL_22->name+57)=')';
*(FCNN_2L_FBALL_22->name+58)=' ';
FCNN_2L_FBALL_22->number_of_Levels=2;
FCNN_2L_FBALL_22->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_2L_FBALL_22->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_22->number_of_Levels);
*(FCNN_2L_FBALL_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_22->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_22->recurrence=T;
FCNN_2L_FBALL_22->number_of_recurrent_connected_layers=1;
FCNN_2L_FBALL_22->source=MAI((long int)FCNN_2L_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22->source+0)=2;
FCNN_2L_FBALL_22->destination=MAI((long int)FCNN_2L_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22->destination+0)=2;
FCNN_2L_FBALL_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_22->create_neuron==0) exit_handling(41,1);
*(FCNN_2L_FBALL_22->create_neuron+0)=create_FCNN_2L_FBALL_22;
FCNN_2L_FBALL_22->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_22->prepare_input=0;
FCNN_2L_FBALL_22->number_linear_output_functions=3;
FCNN_2L_FBALL_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22->node_linear_output==0) exit_handling(41,2);
*(FCNN_2L_FBALL_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_22->number_of_node_output_functions=4;
FCNN_2L_FBALL_22->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22->node_output==0) exit_handling(41,3);
*(FCNN_2L_FBALL_22->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22->node_output_derivation==0) exit_handling(41,4);
*(FCNN_2L_FBALL_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_22->number_of_firing_functions=2;
FCNN_2L_FBALL_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_22->firing_neuron==0) exit_handling(41,5);
*(FCNN_2L_FBALL_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FBALL_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FBALL_22->number_of_learning_algorithms=2;
FCNN_2L_FBALL_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_22->create_learning_algorithm==0) exit_handling(41,6);
*(FCNN_2L_FBALL_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_22);
} /* ; */
/* setting up FCNN_2L_FBALL_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_21 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer on 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_21;
FCNN_2L_FBALL_21=MANTD((long int)1);
FCNN_2L_FBALL_21->name=MAC((long int)59);
*(FCNN_2L_FBALL_21->name+0)='F';
*(FCNN_2L_FBALL_21->name+1)='C';
*(FCNN_2L_FBALL_21->name+2)='N';
*(FCNN_2L_FBALL_21->name+3)='N';
*(FCNN_2L_FBALL_21->name+4)='_';
*(FCNN_2L_FBALL_21->name+5)='2';
*(FCNN_2L_FBALL_21->name+6)='L';
*(FCNN_2L_FBALL_21->name+7)='_';
*(FCNN_2L_FBALL_21->name+8)='F';
*(FCNN_2L_FBALL_21->name+9)='B';
*(FCNN_2L_FBALL_21->name+10)='A';
*(FCNN_2L_FBALL_21->name+11)='L';
*(FCNN_2L_FBALL_21->name+12)='L';
*(FCNN_2L_FBALL_21->name+13)='_';
*(FCNN_2L_FBALL_21->name+14)='2';
*(FCNN_2L_FBALL_21->name+15)='1';
*(FCNN_2L_FBALL_21->name+16)='(';
*(FCNN_2L_FBALL_21->name+17)='F';
*(FCNN_2L_FBALL_21->name+18)='u';
*(FCNN_2L_FBALL_21->name+19)='l';
*(FCNN_2L_FBALL_21->name+20)='l';
*(FCNN_2L_FBALL_21->name+21)='y';
*(FCNN_2L_FBALL_21->name+22)='_';
*(FCNN_2L_FBALL_21->name+23)='C';
*(FCNN_2L_FBALL_21->name+24)='o';
*(FCNN_2L_FBALL_21->name+25)='n';
*(FCNN_2L_FBALL_21->name+26)='n';
*(FCNN_2L_FBALL_21->name+27)='e';
*(FCNN_2L_FBALL_21->name+28)='c';
*(FCNN_2L_FBALL_21->name+29)='t';
*(FCNN_2L_FBALL_21->name+30)='e';
*(FCNN_2L_FBALL_21->name+31)='d';
*(FCNN_2L_FBALL_21->name+32)='_';
*(FCNN_2L_FBALL_21->name+33)='N';
*(FCNN_2L_FBALL_21->name+34)='N';
*(FCNN_2L_FBALL_21->name+35)='_';
*(FCNN_2L_FBALL_21->name+36)='2';
*(FCNN_2L_FBALL_21->name+37)='_';
*(FCNN_2L_FBALL_21->name+38)='L';
*(FCNN_2L_FBALL_21->name+39)='a';
*(FCNN_2L_FBALL_21->name+40)='y';
*(FCNN_2L_FBALL_21->name+41)='e';
*(FCNN_2L_FBALL_21->name+42)='r';
*(FCNN_2L_FBALL_21->name+43)='s';
*(FCNN_2L_FBALL_21->name+44)='_';
*(FCNN_2L_FBALL_21->name+45)='f';
*(FCNN_2L_FBALL_21->name+46)='e';
*(FCNN_2L_FBALL_21->name+47)='e';
*(FCNN_2L_FBALL_21->name+48)='d';
*(FCNN_2L_FBALL_21->name+49)='b';
*(FCNN_2L_FBALL_21->name+50)='a';
*(FCNN_2L_FBALL_21->name+51)='c';
*(FCNN_2L_FBALL_21->name+52)='k';
*(FCNN_2L_FBALL_21->name+53)='_';
*(FCNN_2L_FBALL_21->name+54)='2';
*(FCNN_2L_FBALL_21->name+55)='>';
*(FCNN_2L_FBALL_21->name+56)='1';
*(FCNN_2L_FBALL_21->name+57)=')';
*(FCNN_2L_FBALL_21->name+58)=' ';
FCNN_2L_FBALL_21->number_of_Levels=2;
FCNN_2L_FBALL_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FBALL_21->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_21->number_of_Levels);
*(FCNN_2L_FBALL_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_21->recurrence=T;
FCNN_2L_FBALL_21->number_of_recurrent_connected_layers=1;
FCNN_2L_FBALL_21->source=MAI((long int)FCNN_2L_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_21->source+0)=2;
FCNN_2L_FBALL_21->destination=MAI((long int)FCNN_2L_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_21->destination+0)=1;
FCNN_2L_FBALL_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_21->create_neuron==0) exit_handling(42,1);
*(FCNN_2L_FBALL_21->create_neuron+0)=create_FCNN_2L_FBALL_21;
FCNN_2L_FBALL_21->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_21->prepare_input=0;
FCNN_2L_FBALL_21->number_linear_output_functions=3;
FCNN_2L_FBALL_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_21->node_linear_output==0) exit_handling(42,2);
*(FCNN_2L_FBALL_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_21->number_of_node_output_functions=4;
FCNN_2L_FBALL_21->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_21->node_output==0) exit_handling(42,3);
*(FCNN_2L_FBALL_21->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_21->node_output_derivation==0) exit_handling(42,4);
*(FCNN_2L_FBALL_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_21->number_of_firing_functions=2;
FCNN_2L_FBALL_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_21->firing_neuron==0) exit_handling(42,5);
*(FCNN_2L_FBALL_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_FBALL_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_FBALL_21->number_of_learning_algorithms=2;
FCNN_2L_FBALL_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_21->create_learning_algorithm==0) exit_handling(42,6);
*(FCNN_2L_FBALL_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_21);
} /* ; */
/* setting up FCNN_2L_FBALL_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_22_21 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer on 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_22_21;
FCNN_2L_FBALL_22_21=MANTD((long int)1);
FCNN_2L_FBALL_22_21->name=MAC((long int)70);
*(FCNN_2L_FBALL_22_21->name+0)='F';
*(FCNN_2L_FBALL_22_21->name+1)='C';
*(FCNN_2L_FBALL_22_21->name+2)='N';
*(FCNN_2L_FBALL_22_21->name+3)='N';
*(FCNN_2L_FBALL_22_21->name+4)='_';
*(FCNN_2L_FBALL_22_21->name+5)='2';
*(FCNN_2L_FBALL_22_21->name+6)='L';
*(FCNN_2L_FBALL_22_21->name+7)='_';
*(FCNN_2L_FBALL_22_21->name+8)='F';
*(FCNN_2L_FBALL_22_21->name+9)='B';
*(FCNN_2L_FBALL_22_21->name+10)='A';
*(FCNN_2L_FBALL_22_21->name+11)='L';
*(FCNN_2L_FBALL_22_21->name+12)='L';
*(FCNN_2L_FBALL_22_21->name+13)='_';
*(FCNN_2L_FBALL_22_21->name+14)='2';
*(FCNN_2L_FBALL_22_21->name+15)='2';
*(FCNN_2L_FBALL_22_21->name+16)='_';
*(FCNN_2L_FBALL_22_21->name+17)='2';
*(FCNN_2L_FBALL_22_21->name+18)='1';
*(FCNN_2L_FBALL_22_21->name+19)='(';
*(FCNN_2L_FBALL_22_21->name+20)='F';
*(FCNN_2L_FBALL_22_21->name+21)='u';
*(FCNN_2L_FBALL_22_21->name+22)='l';
*(FCNN_2L_FBALL_22_21->name+23)='l';
*(FCNN_2L_FBALL_22_21->name+24)='y';
*(FCNN_2L_FBALL_22_21->name+25)='_';
*(FCNN_2L_FBALL_22_21->name+26)='C';
*(FCNN_2L_FBALL_22_21->name+27)='o';
*(FCNN_2L_FBALL_22_21->name+28)='n';
*(FCNN_2L_FBALL_22_21->name+29)='n';
*(FCNN_2L_FBALL_22_21->name+30)='e';
*(FCNN_2L_FBALL_22_21->name+31)='c';
*(FCNN_2L_FBALL_22_21->name+32)='t';
*(FCNN_2L_FBALL_22_21->name+33)='e';
*(FCNN_2L_FBALL_22_21->name+34)='d';
*(FCNN_2L_FBALL_22_21->name+35)='_';
*(FCNN_2L_FBALL_22_21->name+36)='N';
*(FCNN_2L_FBALL_22_21->name+37)='N';
*(FCNN_2L_FBALL_22_21->name+38)='_';
*(FCNN_2L_FBALL_22_21->name+39)='2';
*(FCNN_2L_FBALL_22_21->name+40)='_';
*(FCNN_2L_FBALL_22_21->name+41)='L';
*(FCNN_2L_FBALL_22_21->name+42)='a';
*(FCNN_2L_FBALL_22_21->name+43)='y';
*(FCNN_2L_FBALL_22_21->name+44)='e';
*(FCNN_2L_FBALL_22_21->name+45)='r';
*(FCNN_2L_FBALL_22_21->name+46)='s';
*(FCNN_2L_FBALL_22_21->name+47)='_';
*(FCNN_2L_FBALL_22_21->name+48)='f';
*(FCNN_2L_FBALL_22_21->name+49)='e';
*(FCNN_2L_FBALL_22_21->name+50)='e';
*(FCNN_2L_FBALL_22_21->name+51)='d';
*(FCNN_2L_FBALL_22_21->name+52)='b';
*(FCNN_2L_FBALL_22_21->name+53)='a';
*(FCNN_2L_FBALL_22_21->name+54)='c';
*(FCNN_2L_FBALL_22_21->name+55)='k';
*(FCNN_2L_FBALL_22_21->name+56)='_';
*(FCNN_2L_FBALL_22_21->name+57)='2';
*(FCNN_2L_FBALL_22_21->name+58)='>';
*(FCNN_2L_FBALL_22_21->name+59)='2';
*(FCNN_2L_FBALL_22_21->name+60)='_';
*(FCNN_2L_FBALL_22_21->name+61)='a';
*(FCNN_2L_FBALL_22_21->name+62)='n';
*(FCNN_2L_FBALL_22_21->name+63)='d';
*(FCNN_2L_FBALL_22_21->name+64)='_';
*(FCNN_2L_FBALL_22_21->name+65)='2';
*(FCNN_2L_FBALL_22_21->name+66)='>';
*(FCNN_2L_FBALL_22_21->name+67)='1';
*(FCNN_2L_FBALL_22_21->name+68)=')';
*(FCNN_2L_FBALL_22_21->name+69)=' ';
FCNN_2L_FBALL_22_21->number_of_Levels=2;
FCNN_2L_FBALL_22_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FBALL_22_21->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_22_21->number_of_Levels);
*(FCNN_2L_FBALL_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_22_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_22_21->recurrence=T;
FCNN_2L_FBALL_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_FBALL_22_21->source=MAI((long int)FCNN_2L_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22_21->source+0)=2;
*(FCNN_2L_FBALL_22_21->source+1)=2;
FCNN_2L_FBALL_22_21->destination=MAI((long int)FCNN_2L_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22_21->destination+0)=2;
*(FCNN_2L_FBALL_22_21->destination+1)=1;
FCNN_2L_FBALL_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_22_21->create_neuron==0) exit_handling(43,1);
*(FCNN_2L_FBALL_22_21->create_neuron+0)=create_FCNN_2L_FBALL_22_21;
FCNN_2L_FBALL_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_22_21->prepare_input=0;
FCNN_2L_FBALL_22_21->number_linear_output_functions=3;
FCNN_2L_FBALL_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21->node_linear_output==0) exit_handling(43,2);
*(FCNN_2L_FBALL_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_22_21->number_of_node_output_functions=4;
FCNN_2L_FBALL_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21->node_output==0) exit_handling(43,3);
*(FCNN_2L_FBALL_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21->node_output_derivation==0) exit_handling(43,4);
*(FCNN_2L_FBALL_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_22_21->number_of_firing_functions=2;
FCNN_2L_FBALL_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21->firing_neuron==0) exit_handling(43,5);
*(FCNN_2L_FBALL_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FBALL_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FBALL_22_21->number_of_learning_algorithms=2;
FCNN_2L_FBALL_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_22_21->create_learning_algorithm==0) exit_handling(43,6);
*(FCNN_2L_FBALL_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_22_21);
} /* ; */
/* setting up FCNN_2L_FBALL_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_21_11 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer on 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_21_11;
FCNN_2L_FBALL_21_11=MANTD((long int)1);
FCNN_2L_FBALL_21_11->name=MAC((long int)70);
*(FCNN_2L_FBALL_21_11->name+0)='F';
*(FCNN_2L_FBALL_21_11->name+1)='C';
*(FCNN_2L_FBALL_21_11->name+2)='N';
*(FCNN_2L_FBALL_21_11->name+3)='N';
*(FCNN_2L_FBALL_21_11->name+4)='_';
*(FCNN_2L_FBALL_21_11->name+5)='2';
*(FCNN_2L_FBALL_21_11->name+6)='L';
*(FCNN_2L_FBALL_21_11->name+7)='_';
*(FCNN_2L_FBALL_21_11->name+8)='F';
*(FCNN_2L_FBALL_21_11->name+9)='B';
*(FCNN_2L_FBALL_21_11->name+10)='A';
*(FCNN_2L_FBALL_21_11->name+11)='L';
*(FCNN_2L_FBALL_21_11->name+12)='L';
*(FCNN_2L_FBALL_21_11->name+13)='_';
*(FCNN_2L_FBALL_21_11->name+14)='2';
*(FCNN_2L_FBALL_21_11->name+15)='1';
*(FCNN_2L_FBALL_21_11->name+16)='_';
*(FCNN_2L_FBALL_21_11->name+17)='1';
*(FCNN_2L_FBALL_21_11->name+18)='1';
*(FCNN_2L_FBALL_21_11->name+19)='(';
*(FCNN_2L_FBALL_21_11->name+20)='F';
*(FCNN_2L_FBALL_21_11->name+21)='u';
*(FCNN_2L_FBALL_21_11->name+22)='l';
*(FCNN_2L_FBALL_21_11->name+23)='l';
*(FCNN_2L_FBALL_21_11->name+24)='y';
*(FCNN_2L_FBALL_21_11->name+25)='_';
*(FCNN_2L_FBALL_21_11->name+26)='C';
*(FCNN_2L_FBALL_21_11->name+27)='o';
*(FCNN_2L_FBALL_21_11->name+28)='n';
*(FCNN_2L_FBALL_21_11->name+29)='n';
*(FCNN_2L_FBALL_21_11->name+30)='e';
*(FCNN_2L_FBALL_21_11->name+31)='c';
*(FCNN_2L_FBALL_21_11->name+32)='t';
*(FCNN_2L_FBALL_21_11->name+33)='e';
*(FCNN_2L_FBALL_21_11->name+34)='d';
*(FCNN_2L_FBALL_21_11->name+35)='_';
*(FCNN_2L_FBALL_21_11->name+36)='N';
*(FCNN_2L_FBALL_21_11->name+37)='N';
*(FCNN_2L_FBALL_21_11->name+38)='_';
*(FCNN_2L_FBALL_21_11->name+39)='2';
*(FCNN_2L_FBALL_21_11->name+40)='_';
*(FCNN_2L_FBALL_21_11->name+41)='L';
*(FCNN_2L_FBALL_21_11->name+42)='a';
*(FCNN_2L_FBALL_21_11->name+43)='y';
*(FCNN_2L_FBALL_21_11->name+44)='e';
*(FCNN_2L_FBALL_21_11->name+45)='r';
*(FCNN_2L_FBALL_21_11->name+46)='s';
*(FCNN_2L_FBALL_21_11->name+47)='_';
*(FCNN_2L_FBALL_21_11->name+48)='f';
*(FCNN_2L_FBALL_21_11->name+49)='e';
*(FCNN_2L_FBALL_21_11->name+50)='e';
*(FCNN_2L_FBALL_21_11->name+51)='d';
*(FCNN_2L_FBALL_21_11->name+52)='b';
*(FCNN_2L_FBALL_21_11->name+53)='a';
*(FCNN_2L_FBALL_21_11->name+54)='c';
*(FCNN_2L_FBALL_21_11->name+55)='k';
*(FCNN_2L_FBALL_21_11->name+56)='_';
*(FCNN_2L_FBALL_21_11->name+57)='2';
*(FCNN_2L_FBALL_21_11->name+58)='>';
*(FCNN_2L_FBALL_21_11->name+59)='1';
*(FCNN_2L_FBALL_21_11->name+60)='_';
*(FCNN_2L_FBALL_21_11->name+61)='a';
*(FCNN_2L_FBALL_21_11->name+62)='n';
*(FCNN_2L_FBALL_21_11->name+63)='d';
*(FCNN_2L_FBALL_21_11->name+64)='_';
*(FCNN_2L_FBALL_21_11->name+65)='1';
*(FCNN_2L_FBALL_21_11->name+66)='>';
*(FCNN_2L_FBALL_21_11->name+67)='1';
*(FCNN_2L_FBALL_21_11->name+68)=')';
*(FCNN_2L_FBALL_21_11->name+69)=' ';
FCNN_2L_FBALL_21_11->number_of_Levels=2;
FCNN_2L_FBALL_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback (from both itself and the second Level) */
FCNN_2L_FBALL_21_11->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_21_11->number_of_Levels);
*(FCNN_2L_FBALL_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_21_11->recurrence=T;
FCNN_2L_FBALL_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_FBALL_21_11->source=MAI((long int)FCNN_2L_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_21_11->source+0)=2;
*(FCNN_2L_FBALL_21_11->source+1)=1;
FCNN_2L_FBALL_21_11->destination=MAI((long int)FCNN_2L_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_21_11->destination+0)=1;
*(FCNN_2L_FBALL_21_11->destination+1)=1;
FCNN_2L_FBALL_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_21_11->create_neuron==0) exit_handling(44,1);
*(FCNN_2L_FBALL_21_11->create_neuron+0)=create_FCNN_2L_FBALL_21_11;
FCNN_2L_FBALL_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_21_11->prepare_input=0;
FCNN_2L_FBALL_21_11->number_linear_output_functions=3;
FCNN_2L_FBALL_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_21_11->node_linear_output==0) exit_handling(44,2);
*(FCNN_2L_FBALL_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_21_11->number_of_node_output_functions=4;
FCNN_2L_FBALL_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_21_11->node_output==0) exit_handling(44,3);
*(FCNN_2L_FBALL_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_21_11->node_output_derivation==0) exit_handling(44,4);
*(FCNN_2L_FBALL_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_21_11->number_of_firing_functions=2;
FCNN_2L_FBALL_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_21_11->firing_neuron==0) exit_handling(44,5);
*(FCNN_2L_FBALL_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FBALL_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FBALL_21_11->number_of_learning_algorithms=2;
FCNN_2L_FBALL_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_21_11->create_learning_algorithm==0) exit_handling(44,6);
*(FCNN_2L_FBALL_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_21_11);
} /* ; */
/* setting up FCNN_2L_FBALL_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_22_11 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_22_11;
FCNN_2L_FBALL_22_11=MANTD((long int)1);
FCNN_2L_FBALL_22_11->name=MAC((long int)70);
*(FCNN_2L_FBALL_22_11->name+0)='F';
*(FCNN_2L_FBALL_22_11->name+1)='C';
*(FCNN_2L_FBALL_22_11->name+2)='N';
*(FCNN_2L_FBALL_22_11->name+3)='N';
*(FCNN_2L_FBALL_22_11->name+4)='_';
*(FCNN_2L_FBALL_22_11->name+5)='2';
*(FCNN_2L_FBALL_22_11->name+6)='L';
*(FCNN_2L_FBALL_22_11->name+7)='_';
*(FCNN_2L_FBALL_22_11->name+8)='F';
*(FCNN_2L_FBALL_22_11->name+9)='B';
*(FCNN_2L_FBALL_22_11->name+10)='A';
*(FCNN_2L_FBALL_22_11->name+11)='L';
*(FCNN_2L_FBALL_22_11->name+12)='L';
*(FCNN_2L_FBALL_22_11->name+13)='_';
*(FCNN_2L_FBALL_22_11->name+14)='2';
*(FCNN_2L_FBALL_22_11->name+15)='2';
*(FCNN_2L_FBALL_22_11->name+16)='_';
*(FCNN_2L_FBALL_22_11->name+17)='1';
*(FCNN_2L_FBALL_22_11->name+18)='1';
*(FCNN_2L_FBALL_22_11->name+19)='(';
*(FCNN_2L_FBALL_22_11->name+20)='F';
*(FCNN_2L_FBALL_22_11->name+21)='u';
*(FCNN_2L_FBALL_22_11->name+22)='l';
*(FCNN_2L_FBALL_22_11->name+23)='l';
*(FCNN_2L_FBALL_22_11->name+24)='y';
*(FCNN_2L_FBALL_22_11->name+25)='_';
*(FCNN_2L_FBALL_22_11->name+26)='C';
*(FCNN_2L_FBALL_22_11->name+27)='o';
*(FCNN_2L_FBALL_22_11->name+28)='n';
*(FCNN_2L_FBALL_22_11->name+29)='n';
*(FCNN_2L_FBALL_22_11->name+30)='e';
*(FCNN_2L_FBALL_22_11->name+31)='c';
*(FCNN_2L_FBALL_22_11->name+32)='t';
*(FCNN_2L_FBALL_22_11->name+33)='e';
*(FCNN_2L_FBALL_22_11->name+34)='d';
*(FCNN_2L_FBALL_22_11->name+35)='_';
*(FCNN_2L_FBALL_22_11->name+36)='N';
*(FCNN_2L_FBALL_22_11->name+37)='N';
*(FCNN_2L_FBALL_22_11->name+38)='_';
*(FCNN_2L_FBALL_22_11->name+39)='2';
*(FCNN_2L_FBALL_22_11->name+40)='_';
*(FCNN_2L_FBALL_22_11->name+41)='L';
*(FCNN_2L_FBALL_22_11->name+42)='a';
*(FCNN_2L_FBALL_22_11->name+43)='y';
*(FCNN_2L_FBALL_22_11->name+44)='e';
*(FCNN_2L_FBALL_22_11->name+45)='r';
*(FCNN_2L_FBALL_22_11->name+46)='s';
*(FCNN_2L_FBALL_22_11->name+47)='_';
*(FCNN_2L_FBALL_22_11->name+48)='f';
*(FCNN_2L_FBALL_22_11->name+49)='e';
*(FCNN_2L_FBALL_22_11->name+50)='e';
*(FCNN_2L_FBALL_22_11->name+51)='d';
*(FCNN_2L_FBALL_22_11->name+52)='b';
*(FCNN_2L_FBALL_22_11->name+53)='a';
*(FCNN_2L_FBALL_22_11->name+54)='c';
*(FCNN_2L_FBALL_22_11->name+55)='k';
*(FCNN_2L_FBALL_22_11->name+56)='_';
*(FCNN_2L_FBALL_22_11->name+57)='2';
*(FCNN_2L_FBALL_22_11->name+58)='>';
*(FCNN_2L_FBALL_22_11->name+59)='2';
*(FCNN_2L_FBALL_22_11->name+60)='_';
*(FCNN_2L_FBALL_22_11->name+61)='a';
*(FCNN_2L_FBALL_22_11->name+62)='n';
*(FCNN_2L_FBALL_22_11->name+63)='d';
*(FCNN_2L_FBALL_22_11->name+64)='_';
*(FCNN_2L_FBALL_22_11->name+65)='1';
*(FCNN_2L_FBALL_22_11->name+66)='>';
*(FCNN_2L_FBALL_22_11->name+67)='1';
*(FCNN_2L_FBALL_22_11->name+68)=')';
*(FCNN_2L_FBALL_22_11->name+69)=' ';
FCNN_2L_FBALL_22_11->number_of_Levels=2;
FCNN_2L_FBALL_22_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FBALL_22_11->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_22_11->number_of_Levels);
*(FCNN_2L_FBALL_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_22_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_22_11->recurrence=T;
FCNN_2L_FBALL_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_FBALL_22_11->source=MAI((long int)FCNN_2L_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22_11->source+0)=2;
*(FCNN_2L_FBALL_22_11->source+1)=1;
FCNN_2L_FBALL_22_11->destination=MAI((long int)FCNN_2L_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22_11->destination+0)=2;
*(FCNN_2L_FBALL_22_11->destination+1)=1;
FCNN_2L_FBALL_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_22_11->create_neuron==0) exit_handling(45,1);
*(FCNN_2L_FBALL_22_11->create_neuron+0)=create_FCNN_2L_FBALL_22_11;
FCNN_2L_FBALL_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_22_11->prepare_input=0;
FCNN_2L_FBALL_22_11->number_linear_output_functions=3;
FCNN_2L_FBALL_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_11->node_linear_output==0) exit_handling(45,2);
*(FCNN_2L_FBALL_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_22_11->number_of_node_output_functions=4;
FCNN_2L_FBALL_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_11->node_output==0) exit_handling(45,3);
*(FCNN_2L_FBALL_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_11->node_output_derivation==0) exit_handling(45,4);
*(FCNN_2L_FBALL_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_22_11->number_of_firing_functions=2;
FCNN_2L_FBALL_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_11->firing_neuron==0) exit_handling(45,5);
*(FCNN_2L_FBALL_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FBALL_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FBALL_22_11->number_of_learning_algorithms=2;
FCNN_2L_FBALL_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_22_11->create_learning_algorithm==0) exit_handling(45,6);
*(FCNN_2L_FBALL_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_22_11);
} /* ; */
/* setting up FCNN_2L_FBALL_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FBALL_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FBALL_22_21_11 (Fully Connected Neural Network with 2 Layers and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FBALL_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FBALL_22_21_11;
FCNN_2L_FBALL_22_21_11=MANTD((long int)1);
FCNN_2L_FBALL_22_21_11->name=MAC((long int)81);
*(FCNN_2L_FBALL_22_21_11->name+0)='F';
*(FCNN_2L_FBALL_22_21_11->name+1)='C';
*(FCNN_2L_FBALL_22_21_11->name+2)='N';
*(FCNN_2L_FBALL_22_21_11->name+3)='N';
*(FCNN_2L_FBALL_22_21_11->name+4)='_';
*(FCNN_2L_FBALL_22_21_11->name+5)='2';
*(FCNN_2L_FBALL_22_21_11->name+6)='L';
*(FCNN_2L_FBALL_22_21_11->name+7)='_';
*(FCNN_2L_FBALL_22_21_11->name+8)='F';
*(FCNN_2L_FBALL_22_21_11->name+9)='B';
*(FCNN_2L_FBALL_22_21_11->name+10)='A';
*(FCNN_2L_FBALL_22_21_11->name+11)='L';
*(FCNN_2L_FBALL_22_21_11->name+12)='L';
*(FCNN_2L_FBALL_22_21_11->name+13)='_';
*(FCNN_2L_FBALL_22_21_11->name+14)='2';
*(FCNN_2L_FBALL_22_21_11->name+15)='2';
*(FCNN_2L_FBALL_22_21_11->name+16)='_';
*(FCNN_2L_FBALL_22_21_11->name+17)='2';
*(FCNN_2L_FBALL_22_21_11->name+18)='1';
*(FCNN_2L_FBALL_22_21_11->name+19)='_';
*(FCNN_2L_FBALL_22_21_11->name+20)='1';
*(FCNN_2L_FBALL_22_21_11->name+21)='1';
*(FCNN_2L_FBALL_22_21_11->name+22)='(';
*(FCNN_2L_FBALL_22_21_11->name+23)='F';
*(FCNN_2L_FBALL_22_21_11->name+24)='u';
*(FCNN_2L_FBALL_22_21_11->name+25)='l';
*(FCNN_2L_FBALL_22_21_11->name+26)='l';
*(FCNN_2L_FBALL_22_21_11->name+27)='y';
*(FCNN_2L_FBALL_22_21_11->name+28)='_';
*(FCNN_2L_FBALL_22_21_11->name+29)='C';
*(FCNN_2L_FBALL_22_21_11->name+30)='o';
*(FCNN_2L_FBALL_22_21_11->name+31)='n';
*(FCNN_2L_FBALL_22_21_11->name+32)='n';
*(FCNN_2L_FBALL_22_21_11->name+33)='e';
*(FCNN_2L_FBALL_22_21_11->name+34)='c';
*(FCNN_2L_FBALL_22_21_11->name+35)='t';
*(FCNN_2L_FBALL_22_21_11->name+36)='e';
*(FCNN_2L_FBALL_22_21_11->name+37)='d';
*(FCNN_2L_FBALL_22_21_11->name+38)='_';
*(FCNN_2L_FBALL_22_21_11->name+39)='N';
*(FCNN_2L_FBALL_22_21_11->name+40)='N';
*(FCNN_2L_FBALL_22_21_11->name+41)='_';
*(FCNN_2L_FBALL_22_21_11->name+42)='2';
*(FCNN_2L_FBALL_22_21_11->name+43)='_';
*(FCNN_2L_FBALL_22_21_11->name+44)='L';
*(FCNN_2L_FBALL_22_21_11->name+45)='a';
*(FCNN_2L_FBALL_22_21_11->name+46)='y';
*(FCNN_2L_FBALL_22_21_11->name+47)='e';
*(FCNN_2L_FBALL_22_21_11->name+48)='r';
*(FCNN_2L_FBALL_22_21_11->name+49)='s';
*(FCNN_2L_FBALL_22_21_11->name+50)='_';
*(FCNN_2L_FBALL_22_21_11->name+51)='f';
*(FCNN_2L_FBALL_22_21_11->name+52)='e';
*(FCNN_2L_FBALL_22_21_11->name+53)='e';
*(FCNN_2L_FBALL_22_21_11->name+54)='d';
*(FCNN_2L_FBALL_22_21_11->name+55)='b';
*(FCNN_2L_FBALL_22_21_11->name+56)='a';
*(FCNN_2L_FBALL_22_21_11->name+57)='c';
*(FCNN_2L_FBALL_22_21_11->name+58)='k';
*(FCNN_2L_FBALL_22_21_11->name+59)='_';
*(FCNN_2L_FBALL_22_21_11->name+60)='2';
*(FCNN_2L_FBALL_22_21_11->name+61)='>';
*(FCNN_2L_FBALL_22_21_11->name+62)='2';
*(FCNN_2L_FBALL_22_21_11->name+63)='_';
*(FCNN_2L_FBALL_22_21_11->name+64)='a';
*(FCNN_2L_FBALL_22_21_11->name+65)='n';
*(FCNN_2L_FBALL_22_21_11->name+66)='d';
*(FCNN_2L_FBALL_22_21_11->name+67)='_';
*(FCNN_2L_FBALL_22_21_11->name+68)='2';
*(FCNN_2L_FBALL_22_21_11->name+69)='>';
*(FCNN_2L_FBALL_22_21_11->name+70)='1';
*(FCNN_2L_FBALL_22_21_11->name+71)='_';
*(FCNN_2L_FBALL_22_21_11->name+72)='a';
*(FCNN_2L_FBALL_22_21_11->name+73)='n';
*(FCNN_2L_FBALL_22_21_11->name+74)='d';
*(FCNN_2L_FBALL_22_21_11->name+75)='_';
*(FCNN_2L_FBALL_22_21_11->name+76)='1';
*(FCNN_2L_FBALL_22_21_11->name+77)='>';
*(FCNN_2L_FBALL_22_21_11->name+78)='1';
*(FCNN_2L_FBALL_22_21_11->name+79)=')';
*(FCNN_2L_FBALL_22_21_11->name+80)=' ';
FCNN_2L_FBALL_22_21_11->number_of_Levels=2;
FCNN_2L_FBALL_22_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FBALL_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_FBALL_22_21_11->number_of_Levels);
*(FCNN_2L_FBALL_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FBALL_22_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FBALL_22_21_11->recurrence=T;
FCNN_2L_FBALL_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_FBALL_22_21_11->source=MAI((long int)FCNN_2L_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22_21_11->source+0)=2;
*(FCNN_2L_FBALL_22_21_11->source+1)=2;
*(FCNN_2L_FBALL_22_21_11->source+2)=1;
FCNN_2L_FBALL_22_21_11->destination=MAI((long int)FCNN_2L_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FBALL_22_21_11->destination+0)=2;
*(FCNN_2L_FBALL_22_21_11->destination+1)=1;
*(FCNN_2L_FBALL_22_21_11->destination+2)=1;
FCNN_2L_FBALL_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FBALL_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FBALL_22_21_11->create_neuron==0) exit_handling(46,1);
*(FCNN_2L_FBALL_22_21_11->create_neuron+0)=create_FCNN_2L_FBALL_22_21_11;
FCNN_2L_FBALL_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_FBALL_22_21_11->prepare_input=0;
FCNN_2L_FBALL_22_21_11->number_linear_output_functions=3;
FCNN_2L_FBALL_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21_11->node_linear_output==0) exit_handling(46,2);
*(FCNN_2L_FBALL_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FBALL_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FBALL_22_21_11->number_of_node_output_functions=4;
FCNN_2L_FBALL_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21_11->node_output==0) exit_handling(46,3);
*(FCNN_2L_FBALL_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_FBALL_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FBALL_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FBALL_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FBALL_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21_11->node_output_derivation==0) exit_handling(46,4);
*(FCNN_2L_FBALL_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FBALL_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FBALL_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FBALL_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FBALL_22_21_11->number_of_firing_functions=2;
FCNN_2L_FBALL_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FBALL_22_21_11->firing_neuron==0) exit_handling(46,5);
*(FCNN_2L_FBALL_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FBALL_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FBALL_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_FBALL_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FBALL_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FBALL_22_21_11->create_learning_algorithm==0) exit_handling(46,6);
*(FCNN_2L_FBALL_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FBALL_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FBALL_22_21_11);
} /* ; */
/* setting up FCNN_2L_W_FBALL_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_11;
FCNN_2L_W_FBALL_11=MANTD((long int)1);
FCNN_2L_W_FBALL_11->name=MAC((long int)92);
*(FCNN_2L_W_FBALL_11->name+0)='F';
*(FCNN_2L_W_FBALL_11->name+1)='C';
*(FCNN_2L_W_FBALL_11->name+2)='N';
*(FCNN_2L_W_FBALL_11->name+3)='N';
*(FCNN_2L_W_FBALL_11->name+4)='_';
*(FCNN_2L_W_FBALL_11->name+5)='2';
*(FCNN_2L_W_FBALL_11->name+6)='L';
*(FCNN_2L_W_FBALL_11->name+7)='_';
*(FCNN_2L_W_FBALL_11->name+8)='W';
*(FCNN_2L_W_FBALL_11->name+9)='_';
*(FCNN_2L_W_FBALL_11->name+10)='F';
*(FCNN_2L_W_FBALL_11->name+11)='B';
*(FCNN_2L_W_FBALL_11->name+12)='A';
*(FCNN_2L_W_FBALL_11->name+13)='L';
*(FCNN_2L_W_FBALL_11->name+14)='L';
*(FCNN_2L_W_FBALL_11->name+15)='_';
*(FCNN_2L_W_FBALL_11->name+16)='1';
*(FCNN_2L_W_FBALL_11->name+17)='1';
*(FCNN_2L_W_FBALL_11->name+18)='(';
*(FCNN_2L_W_FBALL_11->name+19)='F';
*(FCNN_2L_W_FBALL_11->name+20)='u';
*(FCNN_2L_W_FBALL_11->name+21)='l';
*(FCNN_2L_W_FBALL_11->name+22)='l';
*(FCNN_2L_W_FBALL_11->name+23)='y';
*(FCNN_2L_W_FBALL_11->name+24)='_';
*(FCNN_2L_W_FBALL_11->name+25)='C';
*(FCNN_2L_W_FBALL_11->name+26)='o';
*(FCNN_2L_W_FBALL_11->name+27)='n';
*(FCNN_2L_W_FBALL_11->name+28)='n';
*(FCNN_2L_W_FBALL_11->name+29)='e';
*(FCNN_2L_W_FBALL_11->name+30)='c';
*(FCNN_2L_W_FBALL_11->name+31)='t';
*(FCNN_2L_W_FBALL_11->name+32)='e';
*(FCNN_2L_W_FBALL_11->name+33)='d';
*(FCNN_2L_W_FBALL_11->name+34)='_';
*(FCNN_2L_W_FBALL_11->name+35)='N';
*(FCNN_2L_W_FBALL_11->name+36)='N';
*(FCNN_2L_W_FBALL_11->name+37)='_';
*(FCNN_2L_W_FBALL_11->name+38)='2';
*(FCNN_2L_W_FBALL_11->name+39)='_';
*(FCNN_2L_W_FBALL_11->name+40)='L';
*(FCNN_2L_W_FBALL_11->name+41)='a';
*(FCNN_2L_W_FBALL_11->name+42)='y';
*(FCNN_2L_W_FBALL_11->name+43)='e';
*(FCNN_2L_W_FBALL_11->name+44)='r';
*(FCNN_2L_W_FBALL_11->name+45)='s';
*(FCNN_2L_W_FBALL_11->name+46)='_';
*(FCNN_2L_W_FBALL_11->name+47)='r';
*(FCNN_2L_W_FBALL_11->name+48)='e';
*(FCNN_2L_W_FBALL_11->name+49)='c';
*(FCNN_2L_W_FBALL_11->name+50)='e';
*(FCNN_2L_W_FBALL_11->name+51)='i';
*(FCNN_2L_W_FBALL_11->name+52)='v';
*(FCNN_2L_W_FBALL_11->name+53)='i';
*(FCNN_2L_W_FBALL_11->name+54)='n';
*(FCNN_2L_W_FBALL_11->name+55)='g';
*(FCNN_2L_W_FBALL_11->name+56)='_';
*(FCNN_2L_W_FBALL_11->name+57)='i';
*(FCNN_2L_W_FBALL_11->name+58)='n';
*(FCNN_2L_W_FBALL_11->name+59)='p';
*(FCNN_2L_W_FBALL_11->name+60)='u';
*(FCNN_2L_W_FBALL_11->name+61)='t';
*(FCNN_2L_W_FBALL_11->name+62)='_';
*(FCNN_2L_W_FBALL_11->name+63)='t';
*(FCNN_2L_W_FBALL_11->name+64)='h';
*(FCNN_2L_W_FBALL_11->name+65)='r';
*(FCNN_2L_W_FBALL_11->name+66)='o';
*(FCNN_2L_W_FBALL_11->name+67)='u';
*(FCNN_2L_W_FBALL_11->name+68)='g';
*(FCNN_2L_W_FBALL_11->name+69)='h';
*(FCNN_2L_W_FBALL_11->name+70)='_';
*(FCNN_2L_W_FBALL_11->name+71)='W';
*(FCNN_2L_W_FBALL_11->name+72)='i';
*(FCNN_2L_W_FBALL_11->name+73)='n';
*(FCNN_2L_W_FBALL_11->name+74)='d';
*(FCNN_2L_W_FBALL_11->name+75)='o';
*(FCNN_2L_W_FBALL_11->name+76)='w';
*(FCNN_2L_W_FBALL_11->name+77)='_';
*(FCNN_2L_W_FBALL_11->name+78)='f';
*(FCNN_2L_W_FBALL_11->name+79)='e';
*(FCNN_2L_W_FBALL_11->name+80)='e';
*(FCNN_2L_W_FBALL_11->name+81)='d';
*(FCNN_2L_W_FBALL_11->name+82)='b';
*(FCNN_2L_W_FBALL_11->name+83)='a';
*(FCNN_2L_W_FBALL_11->name+84)='c';
*(FCNN_2L_W_FBALL_11->name+85)='k';
*(FCNN_2L_W_FBALL_11->name+86)='_';
*(FCNN_2L_W_FBALL_11->name+87)='1';
*(FCNN_2L_W_FBALL_11->name+88)='>';
*(FCNN_2L_W_FBALL_11->name+89)='1';
*(FCNN_2L_W_FBALL_11->name+90)=')';
*(FCNN_2L_W_FBALL_11->name+91)=' ';
FCNN_2L_W_FBALL_11->number_of_Levels=2;
FCNN_2L_W_FBALL_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_11->prepare_input()) as well from feedback */
FCNN_2L_W_FBALL_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_11->number_of_Levels);
*(FCNN_2L_W_FBALL_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_11->recurrence=T;
FCNN_2L_W_FBALL_11->number_of_recurrent_connected_layers=1;
FCNN_2L_W_FBALL_11->source=MAI((long int)FCNN_2L_W_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_11->source+0)=1;
FCNN_2L_W_FBALL_11->destination=MAI((long int)FCNN_2L_W_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_11->destination+0)=1;
FCNN_2L_W_FBALL_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_11->create_neuron==0) exit_handling(47,1);
*(FCNN_2L_W_FBALL_11->create_neuron+0)=create_FCNN_2L_FBALL_11;
FCNN_2L_W_FBALL_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_11->number_linear_output_functions=3;
FCNN_2L_W_FBALL_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_11->node_linear_output==0) exit_handling(47,2);
*(FCNN_2L_W_FBALL_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_11->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_11->node_output==0) exit_handling(47,3);
*(FCNN_2L_W_FBALL_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_11->node_output_derivation==0) exit_handling(47,4);
*(FCNN_2L_W_FBALL_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_11->number_of_firing_functions=2;
FCNN_2L_W_FBALL_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_11->firing_neuron==0) exit_handling(47,5);
*(FCNN_2L_W_FBALL_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FBALL_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FBALL_11->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_11->create_learning_algorithm==0) exit_handling(47,6);
*(FCNN_2L_W_FBALL_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_11);
} /* ; */
/* setting up FCNN_2L_W_FBALL_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_22 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_22;
FCNN_2L_W_FBALL_22=MANTD((long int)1);
FCNN_2L_W_FBALL_22->name=MAC((long int)92);
*(FCNN_2L_W_FBALL_22->name+0)='F';
*(FCNN_2L_W_FBALL_22->name+1)='C';
*(FCNN_2L_W_FBALL_22->name+2)='N';
*(FCNN_2L_W_FBALL_22->name+3)='N';
*(FCNN_2L_W_FBALL_22->name+4)='_';
*(FCNN_2L_W_FBALL_22->name+5)='2';
*(FCNN_2L_W_FBALL_22->name+6)='L';
*(FCNN_2L_W_FBALL_22->name+7)='_';
*(FCNN_2L_W_FBALL_22->name+8)='W';
*(FCNN_2L_W_FBALL_22->name+9)='_';
*(FCNN_2L_W_FBALL_22->name+10)='F';
*(FCNN_2L_W_FBALL_22->name+11)='B';
*(FCNN_2L_W_FBALL_22->name+12)='A';
*(FCNN_2L_W_FBALL_22->name+13)='L';
*(FCNN_2L_W_FBALL_22->name+14)='L';
*(FCNN_2L_W_FBALL_22->name+15)='_';
*(FCNN_2L_W_FBALL_22->name+16)='2';
*(FCNN_2L_W_FBALL_22->name+17)='2';
*(FCNN_2L_W_FBALL_22->name+18)='(';
*(FCNN_2L_W_FBALL_22->name+19)='F';
*(FCNN_2L_W_FBALL_22->name+20)='u';
*(FCNN_2L_W_FBALL_22->name+21)='l';
*(FCNN_2L_W_FBALL_22->name+22)='l';
*(FCNN_2L_W_FBALL_22->name+23)='y';
*(FCNN_2L_W_FBALL_22->name+24)='_';
*(FCNN_2L_W_FBALL_22->name+25)='C';
*(FCNN_2L_W_FBALL_22->name+26)='o';
*(FCNN_2L_W_FBALL_22->name+27)='n';
*(FCNN_2L_W_FBALL_22->name+28)='n';
*(FCNN_2L_W_FBALL_22->name+29)='e';
*(FCNN_2L_W_FBALL_22->name+30)='c';
*(FCNN_2L_W_FBALL_22->name+31)='t';
*(FCNN_2L_W_FBALL_22->name+32)='e';
*(FCNN_2L_W_FBALL_22->name+33)='d';
*(FCNN_2L_W_FBALL_22->name+34)='_';
*(FCNN_2L_W_FBALL_22->name+35)='N';
*(FCNN_2L_W_FBALL_22->name+36)='N';
*(FCNN_2L_W_FBALL_22->name+37)='_';
*(FCNN_2L_W_FBALL_22->name+38)='2';
*(FCNN_2L_W_FBALL_22->name+39)='_';
*(FCNN_2L_W_FBALL_22->name+40)='L';
*(FCNN_2L_W_FBALL_22->name+41)='a';
*(FCNN_2L_W_FBALL_22->name+42)='y';
*(FCNN_2L_W_FBALL_22->name+43)='e';
*(FCNN_2L_W_FBALL_22->name+44)='r';
*(FCNN_2L_W_FBALL_22->name+45)='s';
*(FCNN_2L_W_FBALL_22->name+46)='_';
*(FCNN_2L_W_FBALL_22->name+47)='r';
*(FCNN_2L_W_FBALL_22->name+48)='e';
*(FCNN_2L_W_FBALL_22->name+49)='c';
*(FCNN_2L_W_FBALL_22->name+50)='e';
*(FCNN_2L_W_FBALL_22->name+51)='i';
*(FCNN_2L_W_FBALL_22->name+52)='v';
*(FCNN_2L_W_FBALL_22->name+53)='i';
*(FCNN_2L_W_FBALL_22->name+54)='n';
*(FCNN_2L_W_FBALL_22->name+55)='g';
*(FCNN_2L_W_FBALL_22->name+56)='_';
*(FCNN_2L_W_FBALL_22->name+57)='i';
*(FCNN_2L_W_FBALL_22->name+58)='n';
*(FCNN_2L_W_FBALL_22->name+59)='p';
*(FCNN_2L_W_FBALL_22->name+60)='u';
*(FCNN_2L_W_FBALL_22->name+61)='t';
*(FCNN_2L_W_FBALL_22->name+62)='_';
*(FCNN_2L_W_FBALL_22->name+63)='t';
*(FCNN_2L_W_FBALL_22->name+64)='h';
*(FCNN_2L_W_FBALL_22->name+65)='r';
*(FCNN_2L_W_FBALL_22->name+66)='o';
*(FCNN_2L_W_FBALL_22->name+67)='u';
*(FCNN_2L_W_FBALL_22->name+68)='g';
*(FCNN_2L_W_FBALL_22->name+69)='h';
*(FCNN_2L_W_FBALL_22->name+70)='_';
*(FCNN_2L_W_FBALL_22->name+71)='W';
*(FCNN_2L_W_FBALL_22->name+72)='i';
*(FCNN_2L_W_FBALL_22->name+73)='n';
*(FCNN_2L_W_FBALL_22->name+74)='d';
*(FCNN_2L_W_FBALL_22->name+75)='o';
*(FCNN_2L_W_FBALL_22->name+76)='w';
*(FCNN_2L_W_FBALL_22->name+77)='_';
*(FCNN_2L_W_FBALL_22->name+78)='f';
*(FCNN_2L_W_FBALL_22->name+79)='e';
*(FCNN_2L_W_FBALL_22->name+80)='e';
*(FCNN_2L_W_FBALL_22->name+81)='d';
*(FCNN_2L_W_FBALL_22->name+82)='b';
*(FCNN_2L_W_FBALL_22->name+83)='a';
*(FCNN_2L_W_FBALL_22->name+84)='c';
*(FCNN_2L_W_FBALL_22->name+85)='k';
*(FCNN_2L_W_FBALL_22->name+86)='_';
*(FCNN_2L_W_FBALL_22->name+87)='2';
*(FCNN_2L_W_FBALL_22->name+88)='>';
*(FCNN_2L_W_FBALL_22->name+89)='2';
*(FCNN_2L_W_FBALL_22->name+90)=')';
*(FCNN_2L_W_FBALL_22->name+91)=' ';
FCNN_2L_W_FBALL_22->number_of_Levels=2;
FCNN_2L_W_FBALL_22->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_22->prepare_input()) */
FCNN_2L_W_FBALL_22->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_22->number_of_Levels);
*(FCNN_2L_W_FBALL_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_22->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_22->recurrence=T;
FCNN_2L_W_FBALL_22->number_of_recurrent_connected_layers=1;
FCNN_2L_W_FBALL_22->source=MAI((long int)FCNN_2L_W_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22->source+0)=2;
FCNN_2L_W_FBALL_22->destination=MAI((long int)FCNN_2L_W_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22->destination+0)=2;
FCNN_2L_W_FBALL_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_22->create_neuron==0) exit_handling(48,1);
*(FCNN_2L_W_FBALL_22->create_neuron+0)=create_FCNN_2L_FBALL_22;
FCNN_2L_W_FBALL_22->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_22->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_22->number_linear_output_functions=3;
FCNN_2L_W_FBALL_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22->node_linear_output==0) exit_handling(48,2);
*(FCNN_2L_W_FBALL_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_22->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_22->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22->node_output==0) exit_handling(48,3);
*(FCNN_2L_W_FBALL_22->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22->node_output_derivation==0) exit_handling(48,4);
*(FCNN_2L_W_FBALL_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_22->number_of_firing_functions=2;
FCNN_2L_W_FBALL_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22->firing_neuron==0) exit_handling(48,5);
*(FCNN_2L_W_FBALL_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FBALL_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FBALL_22->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_22->create_learning_algorithm==0) exit_handling(48,6);
*(FCNN_2L_W_FBALL_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_22);
} /* ; */
/* setting up FCNN_2L_W_FBALL_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_21;
FCNN_2L_W_FBALL_21=MANTD((long int)1);
FCNN_2L_W_FBALL_21->name=MAC((long int)92);
*(FCNN_2L_W_FBALL_21->name+0)='F';
*(FCNN_2L_W_FBALL_21->name+1)='C';
*(FCNN_2L_W_FBALL_21->name+2)='N';
*(FCNN_2L_W_FBALL_21->name+3)='N';
*(FCNN_2L_W_FBALL_21->name+4)='_';
*(FCNN_2L_W_FBALL_21->name+5)='2';
*(FCNN_2L_W_FBALL_21->name+6)='L';
*(FCNN_2L_W_FBALL_21->name+7)='_';
*(FCNN_2L_W_FBALL_21->name+8)='W';
*(FCNN_2L_W_FBALL_21->name+9)='_';
*(FCNN_2L_W_FBALL_21->name+10)='F';
*(FCNN_2L_W_FBALL_21->name+11)='B';
*(FCNN_2L_W_FBALL_21->name+12)='A';
*(FCNN_2L_W_FBALL_21->name+13)='L';
*(FCNN_2L_W_FBALL_21->name+14)='L';
*(FCNN_2L_W_FBALL_21->name+15)='_';
*(FCNN_2L_W_FBALL_21->name+16)='2';
*(FCNN_2L_W_FBALL_21->name+17)='1';
*(FCNN_2L_W_FBALL_21->name+18)='(';
*(FCNN_2L_W_FBALL_21->name+19)='F';
*(FCNN_2L_W_FBALL_21->name+20)='u';
*(FCNN_2L_W_FBALL_21->name+21)='l';
*(FCNN_2L_W_FBALL_21->name+22)='l';
*(FCNN_2L_W_FBALL_21->name+23)='y';
*(FCNN_2L_W_FBALL_21->name+24)='_';
*(FCNN_2L_W_FBALL_21->name+25)='C';
*(FCNN_2L_W_FBALL_21->name+26)='o';
*(FCNN_2L_W_FBALL_21->name+27)='n';
*(FCNN_2L_W_FBALL_21->name+28)='n';
*(FCNN_2L_W_FBALL_21->name+29)='e';
*(FCNN_2L_W_FBALL_21->name+30)='c';
*(FCNN_2L_W_FBALL_21->name+31)='t';
*(FCNN_2L_W_FBALL_21->name+32)='e';
*(FCNN_2L_W_FBALL_21->name+33)='d';
*(FCNN_2L_W_FBALL_21->name+34)='_';
*(FCNN_2L_W_FBALL_21->name+35)='N';
*(FCNN_2L_W_FBALL_21->name+36)='N';
*(FCNN_2L_W_FBALL_21->name+37)='_';
*(FCNN_2L_W_FBALL_21->name+38)='2';
*(FCNN_2L_W_FBALL_21->name+39)='_';
*(FCNN_2L_W_FBALL_21->name+40)='L';
*(FCNN_2L_W_FBALL_21->name+41)='a';
*(FCNN_2L_W_FBALL_21->name+42)='y';
*(FCNN_2L_W_FBALL_21->name+43)='e';
*(FCNN_2L_W_FBALL_21->name+44)='r';
*(FCNN_2L_W_FBALL_21->name+45)='s';
*(FCNN_2L_W_FBALL_21->name+46)='_';
*(FCNN_2L_W_FBALL_21->name+47)='r';
*(FCNN_2L_W_FBALL_21->name+48)='e';
*(FCNN_2L_W_FBALL_21->name+49)='c';
*(FCNN_2L_W_FBALL_21->name+50)='e';
*(FCNN_2L_W_FBALL_21->name+51)='i';
*(FCNN_2L_W_FBALL_21->name+52)='v';
*(FCNN_2L_W_FBALL_21->name+53)='i';
*(FCNN_2L_W_FBALL_21->name+54)='n';
*(FCNN_2L_W_FBALL_21->name+55)='g';
*(FCNN_2L_W_FBALL_21->name+56)='_';
*(FCNN_2L_W_FBALL_21->name+57)='i';
*(FCNN_2L_W_FBALL_21->name+58)='n';
*(FCNN_2L_W_FBALL_21->name+59)='p';
*(FCNN_2L_W_FBALL_21->name+60)='u';
*(FCNN_2L_W_FBALL_21->name+61)='t';
*(FCNN_2L_W_FBALL_21->name+62)='_';
*(FCNN_2L_W_FBALL_21->name+63)='t';
*(FCNN_2L_W_FBALL_21->name+64)='h';
*(FCNN_2L_W_FBALL_21->name+65)='r';
*(FCNN_2L_W_FBALL_21->name+66)='o';
*(FCNN_2L_W_FBALL_21->name+67)='u';
*(FCNN_2L_W_FBALL_21->name+68)='g';
*(FCNN_2L_W_FBALL_21->name+69)='h';
*(FCNN_2L_W_FBALL_21->name+70)='_';
*(FCNN_2L_W_FBALL_21->name+71)='W';
*(FCNN_2L_W_FBALL_21->name+72)='i';
*(FCNN_2L_W_FBALL_21->name+73)='n';
*(FCNN_2L_W_FBALL_21->name+74)='d';
*(FCNN_2L_W_FBALL_21->name+75)='o';
*(FCNN_2L_W_FBALL_21->name+76)='w';
*(FCNN_2L_W_FBALL_21->name+77)='_';
*(FCNN_2L_W_FBALL_21->name+78)='f';
*(FCNN_2L_W_FBALL_21->name+79)='e';
*(FCNN_2L_W_FBALL_21->name+80)='e';
*(FCNN_2L_W_FBALL_21->name+81)='d';
*(FCNN_2L_W_FBALL_21->name+82)='b';
*(FCNN_2L_W_FBALL_21->name+83)='a';
*(FCNN_2L_W_FBALL_21->name+84)='c';
*(FCNN_2L_W_FBALL_21->name+85)='k';
*(FCNN_2L_W_FBALL_21->name+86)='_';
*(FCNN_2L_W_FBALL_21->name+87)='2';
*(FCNN_2L_W_FBALL_21->name+88)='>';
*(FCNN_2L_W_FBALL_21->name+89)='1';
*(FCNN_2L_W_FBALL_21->name+90)=')';
*(FCNN_2L_W_FBALL_21->name+91)=' ';
FCNN_2L_W_FBALL_21->number_of_Levels=2;
FCNN_2L_W_FBALL_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_21->prepare_input()) as well from feedback */
FCNN_2L_W_FBALL_21->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_21->number_of_Levels);
*(FCNN_2L_W_FBALL_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_21->recurrence=T;
FCNN_2L_W_FBALL_21->number_of_recurrent_connected_layers=1;
FCNN_2L_W_FBALL_21->source=MAI((long int)FCNN_2L_W_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_21->source+0)=2;
FCNN_2L_W_FBALL_21->destination=MAI((long int)FCNN_2L_W_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_21->destination+0)=1;
FCNN_2L_W_FBALL_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_21->create_neuron==0) exit_handling(49,1);
*(FCNN_2L_W_FBALL_21->create_neuron+0)=create_FCNN_2L_FBALL_21;
FCNN_2L_W_FBALL_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_21->number_linear_output_functions=3;
FCNN_2L_W_FBALL_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21->node_linear_output==0) exit_handling(49,2);
*(FCNN_2L_W_FBALL_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_21->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21->node_output==0) exit_handling(49,3);
*(FCNN_2L_W_FBALL_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21->node_output_derivation==0) exit_handling(49,4);
*(FCNN_2L_W_FBALL_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_21->number_of_firing_functions=2;
FCNN_2L_W_FBALL_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21->firing_neuron==0) exit_handling(49,5);
*(FCNN_2L_W_FBALL_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_W_FBALL_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_W_FBALL_21->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_21->create_learning_algorithm==0) exit_handling(49,6);
*(FCNN_2L_W_FBALL_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_21);
} /* ; */
/* setting up FCNN_2L_W_FBALL_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_22_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_22_11;
FCNN_2L_W_FBALL_22_11=MANTD((long int)1);
FCNN_2L_W_FBALL_22_11->name=MAC((long int)103);
*(FCNN_2L_W_FBALL_22_11->name+0)='F';
*(FCNN_2L_W_FBALL_22_11->name+1)='C';
*(FCNN_2L_W_FBALL_22_11->name+2)='N';
*(FCNN_2L_W_FBALL_22_11->name+3)='N';
*(FCNN_2L_W_FBALL_22_11->name+4)='_';
*(FCNN_2L_W_FBALL_22_11->name+5)='2';
*(FCNN_2L_W_FBALL_22_11->name+6)='L';
*(FCNN_2L_W_FBALL_22_11->name+7)='_';
*(FCNN_2L_W_FBALL_22_11->name+8)='W';
*(FCNN_2L_W_FBALL_22_11->name+9)='_';
*(FCNN_2L_W_FBALL_22_11->name+10)='F';
*(FCNN_2L_W_FBALL_22_11->name+11)='B';
*(FCNN_2L_W_FBALL_22_11->name+12)='A';
*(FCNN_2L_W_FBALL_22_11->name+13)='L';
*(FCNN_2L_W_FBALL_22_11->name+14)='L';
*(FCNN_2L_W_FBALL_22_11->name+15)='_';
*(FCNN_2L_W_FBALL_22_11->name+16)='2';
*(FCNN_2L_W_FBALL_22_11->name+17)='2';
*(FCNN_2L_W_FBALL_22_11->name+18)='_';
*(FCNN_2L_W_FBALL_22_11->name+19)='1';
*(FCNN_2L_W_FBALL_22_11->name+20)='1';
*(FCNN_2L_W_FBALL_22_11->name+21)='(';
*(FCNN_2L_W_FBALL_22_11->name+22)='F';
*(FCNN_2L_W_FBALL_22_11->name+23)='u';
*(FCNN_2L_W_FBALL_22_11->name+24)='l';
*(FCNN_2L_W_FBALL_22_11->name+25)='l';
*(FCNN_2L_W_FBALL_22_11->name+26)='y';
*(FCNN_2L_W_FBALL_22_11->name+27)='_';
*(FCNN_2L_W_FBALL_22_11->name+28)='C';
*(FCNN_2L_W_FBALL_22_11->name+29)='o';
*(FCNN_2L_W_FBALL_22_11->name+30)='n';
*(FCNN_2L_W_FBALL_22_11->name+31)='n';
*(FCNN_2L_W_FBALL_22_11->name+32)='e';
*(FCNN_2L_W_FBALL_22_11->name+33)='c';
*(FCNN_2L_W_FBALL_22_11->name+34)='t';
*(FCNN_2L_W_FBALL_22_11->name+35)='e';
*(FCNN_2L_W_FBALL_22_11->name+36)='d';
*(FCNN_2L_W_FBALL_22_11->name+37)='_';
*(FCNN_2L_W_FBALL_22_11->name+38)='N';
*(FCNN_2L_W_FBALL_22_11->name+39)='N';
*(FCNN_2L_W_FBALL_22_11->name+40)='_';
*(FCNN_2L_W_FBALL_22_11->name+41)='2';
*(FCNN_2L_W_FBALL_22_11->name+42)='_';
*(FCNN_2L_W_FBALL_22_11->name+43)='L';
*(FCNN_2L_W_FBALL_22_11->name+44)='a';
*(FCNN_2L_W_FBALL_22_11->name+45)='y';
*(FCNN_2L_W_FBALL_22_11->name+46)='e';
*(FCNN_2L_W_FBALL_22_11->name+47)='r';
*(FCNN_2L_W_FBALL_22_11->name+48)='s';
*(FCNN_2L_W_FBALL_22_11->name+49)='_';
*(FCNN_2L_W_FBALL_22_11->name+50)='r';
*(FCNN_2L_W_FBALL_22_11->name+51)='e';
*(FCNN_2L_W_FBALL_22_11->name+52)='c';
*(FCNN_2L_W_FBALL_22_11->name+53)='e';
*(FCNN_2L_W_FBALL_22_11->name+54)='i';
*(FCNN_2L_W_FBALL_22_11->name+55)='v';
*(FCNN_2L_W_FBALL_22_11->name+56)='i';
*(FCNN_2L_W_FBALL_22_11->name+57)='n';
*(FCNN_2L_W_FBALL_22_11->name+58)='g';
*(FCNN_2L_W_FBALL_22_11->name+59)='_';
*(FCNN_2L_W_FBALL_22_11->name+60)='i';
*(FCNN_2L_W_FBALL_22_11->name+61)='n';
*(FCNN_2L_W_FBALL_22_11->name+62)='p';
*(FCNN_2L_W_FBALL_22_11->name+63)='u';
*(FCNN_2L_W_FBALL_22_11->name+64)='t';
*(FCNN_2L_W_FBALL_22_11->name+65)='_';
*(FCNN_2L_W_FBALL_22_11->name+66)='t';
*(FCNN_2L_W_FBALL_22_11->name+67)='h';
*(FCNN_2L_W_FBALL_22_11->name+68)='r';
*(FCNN_2L_W_FBALL_22_11->name+69)='o';
*(FCNN_2L_W_FBALL_22_11->name+70)='u';
*(FCNN_2L_W_FBALL_22_11->name+71)='g';
*(FCNN_2L_W_FBALL_22_11->name+72)='h';
*(FCNN_2L_W_FBALL_22_11->name+73)='_';
*(FCNN_2L_W_FBALL_22_11->name+74)='W';
*(FCNN_2L_W_FBALL_22_11->name+75)='i';
*(FCNN_2L_W_FBALL_22_11->name+76)='n';
*(FCNN_2L_W_FBALL_22_11->name+77)='d';
*(FCNN_2L_W_FBALL_22_11->name+78)='o';
*(FCNN_2L_W_FBALL_22_11->name+79)='w';
*(FCNN_2L_W_FBALL_22_11->name+80)='_';
*(FCNN_2L_W_FBALL_22_11->name+81)='f';
*(FCNN_2L_W_FBALL_22_11->name+82)='e';
*(FCNN_2L_W_FBALL_22_11->name+83)='e';
*(FCNN_2L_W_FBALL_22_11->name+84)='d';
*(FCNN_2L_W_FBALL_22_11->name+85)='b';
*(FCNN_2L_W_FBALL_22_11->name+86)='a';
*(FCNN_2L_W_FBALL_22_11->name+87)='c';
*(FCNN_2L_W_FBALL_22_11->name+88)='k';
*(FCNN_2L_W_FBALL_22_11->name+89)='_';
*(FCNN_2L_W_FBALL_22_11->name+90)='2';
*(FCNN_2L_W_FBALL_22_11->name+91)='>';
*(FCNN_2L_W_FBALL_22_11->name+92)='2';
*(FCNN_2L_W_FBALL_22_11->name+93)='_';
*(FCNN_2L_W_FBALL_22_11->name+94)='a';
*(FCNN_2L_W_FBALL_22_11->name+95)='n';
*(FCNN_2L_W_FBALL_22_11->name+96)='d';
*(FCNN_2L_W_FBALL_22_11->name+97)='_';
*(FCNN_2L_W_FBALL_22_11->name+98)='1';
*(FCNN_2L_W_FBALL_22_11->name+99)='>';
*(FCNN_2L_W_FBALL_22_11->name+100)='1';
*(FCNN_2L_W_FBALL_22_11->name+101)=')';
*(FCNN_2L_W_FBALL_22_11->name+102)=' ';
FCNN_2L_W_FBALL_22_11->number_of_Levels=2;
FCNN_2L_W_FBALL_22_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_22_11->prepare_input()) as well from feedback */
FCNN_2L_W_FBALL_22_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_22_11->number_of_Levels);
*(FCNN_2L_W_FBALL_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_22_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_22_11->recurrence=T;
FCNN_2L_W_FBALL_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_FBALL_22_11->source=MAI((long int)FCNN_2L_W_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22_11->source+0)=2;
*(FCNN_2L_W_FBALL_22_11->source+1)=1;
FCNN_2L_W_FBALL_22_11->destination=MAI((long int)FCNN_2L_W_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22_11->destination+0)=2;
*(FCNN_2L_W_FBALL_22_11->destination+1)=1;
FCNN_2L_W_FBALL_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_22_11->create_neuron==0) exit_handling(50,1);
*(FCNN_2L_W_FBALL_22_11->create_neuron+0)=create_FCNN_2L_FBALL_22_11;
FCNN_2L_W_FBALL_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_22_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_22_11->number_linear_output_functions=3;
FCNN_2L_W_FBALL_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_11->node_linear_output==0) exit_handling(50,2);
*(FCNN_2L_W_FBALL_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_22_11->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_11->node_output==0) exit_handling(50,3);
*(FCNN_2L_W_FBALL_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_11->node_output_derivation==0) exit_handling(50,4);
*(FCNN_2L_W_FBALL_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_22_11->number_of_firing_functions=2;
FCNN_2L_W_FBALL_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_11->firing_neuron==0) exit_handling(50,5);
*(FCNN_2L_W_FBALL_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FBALL_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FBALL_22_11->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_22_11->create_learning_algorithm==0) exit_handling(50,6);
*(FCNN_2L_W_FBALL_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_22_11);
} /* ; */
/* setting up FCNN_2L_W_FBALL_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_21_11;
FCNN_2L_W_FBALL_21_11=MANTD((long int)1);
FCNN_2L_W_FBALL_21_11->name=MAC((long int)103);
*(FCNN_2L_W_FBALL_21_11->name+0)='F';
*(FCNN_2L_W_FBALL_21_11->name+1)='C';
*(FCNN_2L_W_FBALL_21_11->name+2)='N';
*(FCNN_2L_W_FBALL_21_11->name+3)='N';
*(FCNN_2L_W_FBALL_21_11->name+4)='_';
*(FCNN_2L_W_FBALL_21_11->name+5)='2';
*(FCNN_2L_W_FBALL_21_11->name+6)='L';
*(FCNN_2L_W_FBALL_21_11->name+7)='_';
*(FCNN_2L_W_FBALL_21_11->name+8)='W';
*(FCNN_2L_W_FBALL_21_11->name+9)='_';
*(FCNN_2L_W_FBALL_21_11->name+10)='F';
*(FCNN_2L_W_FBALL_21_11->name+11)='B';
*(FCNN_2L_W_FBALL_21_11->name+12)='A';
*(FCNN_2L_W_FBALL_21_11->name+13)='L';
*(FCNN_2L_W_FBALL_21_11->name+14)='L';
*(FCNN_2L_W_FBALL_21_11->name+15)='_';
*(FCNN_2L_W_FBALL_21_11->name+16)='2';
*(FCNN_2L_W_FBALL_21_11->name+17)='1';
*(FCNN_2L_W_FBALL_21_11->name+18)='_';
*(FCNN_2L_W_FBALL_21_11->name+19)='1';
*(FCNN_2L_W_FBALL_21_11->name+20)='1';
*(FCNN_2L_W_FBALL_21_11->name+21)='(';
*(FCNN_2L_W_FBALL_21_11->name+22)='F';
*(FCNN_2L_W_FBALL_21_11->name+23)='u';
*(FCNN_2L_W_FBALL_21_11->name+24)='l';
*(FCNN_2L_W_FBALL_21_11->name+25)='l';
*(FCNN_2L_W_FBALL_21_11->name+26)='y';
*(FCNN_2L_W_FBALL_21_11->name+27)='_';
*(FCNN_2L_W_FBALL_21_11->name+28)='C';
*(FCNN_2L_W_FBALL_21_11->name+29)='o';
*(FCNN_2L_W_FBALL_21_11->name+30)='n';
*(FCNN_2L_W_FBALL_21_11->name+31)='n';
*(FCNN_2L_W_FBALL_21_11->name+32)='e';
*(FCNN_2L_W_FBALL_21_11->name+33)='c';
*(FCNN_2L_W_FBALL_21_11->name+34)='t';
*(FCNN_2L_W_FBALL_21_11->name+35)='e';
*(FCNN_2L_W_FBALL_21_11->name+36)='d';
*(FCNN_2L_W_FBALL_21_11->name+37)='_';
*(FCNN_2L_W_FBALL_21_11->name+38)='N';
*(FCNN_2L_W_FBALL_21_11->name+39)='N';
*(FCNN_2L_W_FBALL_21_11->name+40)='_';
*(FCNN_2L_W_FBALL_21_11->name+41)='2';
*(FCNN_2L_W_FBALL_21_11->name+42)='_';
*(FCNN_2L_W_FBALL_21_11->name+43)='L';
*(FCNN_2L_W_FBALL_21_11->name+44)='a';
*(FCNN_2L_W_FBALL_21_11->name+45)='y';
*(FCNN_2L_W_FBALL_21_11->name+46)='e';
*(FCNN_2L_W_FBALL_21_11->name+47)='r';
*(FCNN_2L_W_FBALL_21_11->name+48)='s';
*(FCNN_2L_W_FBALL_21_11->name+49)='_';
*(FCNN_2L_W_FBALL_21_11->name+50)='r';
*(FCNN_2L_W_FBALL_21_11->name+51)='e';
*(FCNN_2L_W_FBALL_21_11->name+52)='c';
*(FCNN_2L_W_FBALL_21_11->name+53)='e';
*(FCNN_2L_W_FBALL_21_11->name+54)='i';
*(FCNN_2L_W_FBALL_21_11->name+55)='v';
*(FCNN_2L_W_FBALL_21_11->name+56)='i';
*(FCNN_2L_W_FBALL_21_11->name+57)='n';
*(FCNN_2L_W_FBALL_21_11->name+58)='g';
*(FCNN_2L_W_FBALL_21_11->name+59)='_';
*(FCNN_2L_W_FBALL_21_11->name+60)='i';
*(FCNN_2L_W_FBALL_21_11->name+61)='n';
*(FCNN_2L_W_FBALL_21_11->name+62)='p';
*(FCNN_2L_W_FBALL_21_11->name+63)='u';
*(FCNN_2L_W_FBALL_21_11->name+64)='t';
*(FCNN_2L_W_FBALL_21_11->name+65)='_';
*(FCNN_2L_W_FBALL_21_11->name+66)='t';
*(FCNN_2L_W_FBALL_21_11->name+67)='h';
*(FCNN_2L_W_FBALL_21_11->name+68)='r';
*(FCNN_2L_W_FBALL_21_11->name+69)='o';
*(FCNN_2L_W_FBALL_21_11->name+70)='u';
*(FCNN_2L_W_FBALL_21_11->name+71)='g';
*(FCNN_2L_W_FBALL_21_11->name+72)='h';
*(FCNN_2L_W_FBALL_21_11->name+73)='_';
*(FCNN_2L_W_FBALL_21_11->name+74)='W';
*(FCNN_2L_W_FBALL_21_11->name+75)='i';
*(FCNN_2L_W_FBALL_21_11->name+76)='n';
*(FCNN_2L_W_FBALL_21_11->name+77)='d';
*(FCNN_2L_W_FBALL_21_11->name+78)='o';
*(FCNN_2L_W_FBALL_21_11->name+79)='w';
*(FCNN_2L_W_FBALL_21_11->name+80)='_';
*(FCNN_2L_W_FBALL_21_11->name+81)='f';
*(FCNN_2L_W_FBALL_21_11->name+82)='e';
*(FCNN_2L_W_FBALL_21_11->name+83)='e';
*(FCNN_2L_W_FBALL_21_11->name+84)='d';
*(FCNN_2L_W_FBALL_21_11->name+85)='b';
*(FCNN_2L_W_FBALL_21_11->name+86)='a';
*(FCNN_2L_W_FBALL_21_11->name+87)='c';
*(FCNN_2L_W_FBALL_21_11->name+88)='k';
*(FCNN_2L_W_FBALL_21_11->name+89)='_';
*(FCNN_2L_W_FBALL_21_11->name+90)='2';
*(FCNN_2L_W_FBALL_21_11->name+91)='>';
*(FCNN_2L_W_FBALL_21_11->name+92)='1';
*(FCNN_2L_W_FBALL_21_11->name+93)='_';
*(FCNN_2L_W_FBALL_21_11->name+94)='a';
*(FCNN_2L_W_FBALL_21_11->name+95)='n';
*(FCNN_2L_W_FBALL_21_11->name+96)='d';
*(FCNN_2L_W_FBALL_21_11->name+97)='_';
*(FCNN_2L_W_FBALL_21_11->name+98)='1';
*(FCNN_2L_W_FBALL_21_11->name+99)='>';
*(FCNN_2L_W_FBALL_21_11->name+100)='1';
*(FCNN_2L_W_FBALL_21_11->name+101)=')';
*(FCNN_2L_W_FBALL_21_11->name+102)=' ';
FCNN_2L_W_FBALL_21_11->number_of_Levels=2;
FCNN_2L_W_FBALL_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_21_11->prepare_input()) as well from feedback */
FCNN_2L_W_FBALL_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_21_11->number_of_Levels);
*(FCNN_2L_W_FBALL_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_21_11->recurrence=T;
FCNN_2L_W_FBALL_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_FBALL_21_11->source=MAI((long int)FCNN_2L_W_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_21_11->source+0)=2;
*(FCNN_2L_W_FBALL_21_11->source+1)=1;
FCNN_2L_W_FBALL_21_11->destination=MAI((long int)FCNN_2L_W_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_21_11->destination+0)=1;
*(FCNN_2L_W_FBALL_21_11->destination+1)=1;
FCNN_2L_W_FBALL_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_21_11->create_neuron==0) exit_handling(51,1);
*(FCNN_2L_W_FBALL_21_11->create_neuron+0)=create_FCNN_2L_FBALL_21_11;
FCNN_2L_W_FBALL_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_21_11->number_linear_output_functions=3;
FCNN_2L_W_FBALL_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21_11->node_linear_output==0) exit_handling(51,2);
*(FCNN_2L_W_FBALL_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_21_11->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21_11->node_output==0) exit_handling(51,3);
*(FCNN_2L_W_FBALL_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21_11->node_output_derivation==0) exit_handling(51,4);
*(FCNN_2L_W_FBALL_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_21_11->number_of_firing_functions=2;
FCNN_2L_W_FBALL_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_21_11->firing_neuron==0) exit_handling(51,5);
*(FCNN_2L_W_FBALL_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FBALL_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FBALL_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_21_11->create_learning_algorithm==0) exit_handling(51,6);
*(FCNN_2L_W_FBALL_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_21_11);
} /* ; */
/* setting up FCNN_2L_W_FBALL_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_22_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_22_21;
FCNN_2L_W_FBALL_22_21=MANTD((long int)1);
FCNN_2L_W_FBALL_22_21->name=MAC((long int)103);
*(FCNN_2L_W_FBALL_22_21->name+0)='F';
*(FCNN_2L_W_FBALL_22_21->name+1)='C';
*(FCNN_2L_W_FBALL_22_21->name+2)='N';
*(FCNN_2L_W_FBALL_22_21->name+3)='N';
*(FCNN_2L_W_FBALL_22_21->name+4)='_';
*(FCNN_2L_W_FBALL_22_21->name+5)='2';
*(FCNN_2L_W_FBALL_22_21->name+6)='L';
*(FCNN_2L_W_FBALL_22_21->name+7)='_';
*(FCNN_2L_W_FBALL_22_21->name+8)='W';
*(FCNN_2L_W_FBALL_22_21->name+9)='_';
*(FCNN_2L_W_FBALL_22_21->name+10)='F';
*(FCNN_2L_W_FBALL_22_21->name+11)='B';
*(FCNN_2L_W_FBALL_22_21->name+12)='A';
*(FCNN_2L_W_FBALL_22_21->name+13)='L';
*(FCNN_2L_W_FBALL_22_21->name+14)='L';
*(FCNN_2L_W_FBALL_22_21->name+15)='_';
*(FCNN_2L_W_FBALL_22_21->name+16)='2';
*(FCNN_2L_W_FBALL_22_21->name+17)='2';
*(FCNN_2L_W_FBALL_22_21->name+18)='_';
*(FCNN_2L_W_FBALL_22_21->name+19)='2';
*(FCNN_2L_W_FBALL_22_21->name+20)='1';
*(FCNN_2L_W_FBALL_22_21->name+21)='(';
*(FCNN_2L_W_FBALL_22_21->name+22)='F';
*(FCNN_2L_W_FBALL_22_21->name+23)='u';
*(FCNN_2L_W_FBALL_22_21->name+24)='l';
*(FCNN_2L_W_FBALL_22_21->name+25)='l';
*(FCNN_2L_W_FBALL_22_21->name+26)='y';
*(FCNN_2L_W_FBALL_22_21->name+27)='_';
*(FCNN_2L_W_FBALL_22_21->name+28)='C';
*(FCNN_2L_W_FBALL_22_21->name+29)='o';
*(FCNN_2L_W_FBALL_22_21->name+30)='n';
*(FCNN_2L_W_FBALL_22_21->name+31)='n';
*(FCNN_2L_W_FBALL_22_21->name+32)='e';
*(FCNN_2L_W_FBALL_22_21->name+33)='c';
*(FCNN_2L_W_FBALL_22_21->name+34)='t';
*(FCNN_2L_W_FBALL_22_21->name+35)='e';
*(FCNN_2L_W_FBALL_22_21->name+36)='d';
*(FCNN_2L_W_FBALL_22_21->name+37)='_';
*(FCNN_2L_W_FBALL_22_21->name+38)='N';
*(FCNN_2L_W_FBALL_22_21->name+39)='N';
*(FCNN_2L_W_FBALL_22_21->name+40)='_';
*(FCNN_2L_W_FBALL_22_21->name+41)='2';
*(FCNN_2L_W_FBALL_22_21->name+42)='_';
*(FCNN_2L_W_FBALL_22_21->name+43)='L';
*(FCNN_2L_W_FBALL_22_21->name+44)='a';
*(FCNN_2L_W_FBALL_22_21->name+45)='y';
*(FCNN_2L_W_FBALL_22_21->name+46)='e';
*(FCNN_2L_W_FBALL_22_21->name+47)='r';
*(FCNN_2L_W_FBALL_22_21->name+48)='s';
*(FCNN_2L_W_FBALL_22_21->name+49)='_';
*(FCNN_2L_W_FBALL_22_21->name+50)='r';
*(FCNN_2L_W_FBALL_22_21->name+51)='e';
*(FCNN_2L_W_FBALL_22_21->name+52)='c';
*(FCNN_2L_W_FBALL_22_21->name+53)='e';
*(FCNN_2L_W_FBALL_22_21->name+54)='i';
*(FCNN_2L_W_FBALL_22_21->name+55)='v';
*(FCNN_2L_W_FBALL_22_21->name+56)='i';
*(FCNN_2L_W_FBALL_22_21->name+57)='n';
*(FCNN_2L_W_FBALL_22_21->name+58)='g';
*(FCNN_2L_W_FBALL_22_21->name+59)='_';
*(FCNN_2L_W_FBALL_22_21->name+60)='i';
*(FCNN_2L_W_FBALL_22_21->name+61)='n';
*(FCNN_2L_W_FBALL_22_21->name+62)='p';
*(FCNN_2L_W_FBALL_22_21->name+63)='u';
*(FCNN_2L_W_FBALL_22_21->name+64)='t';
*(FCNN_2L_W_FBALL_22_21->name+65)='_';
*(FCNN_2L_W_FBALL_22_21->name+66)='t';
*(FCNN_2L_W_FBALL_22_21->name+67)='h';
*(FCNN_2L_W_FBALL_22_21->name+68)='r';
*(FCNN_2L_W_FBALL_22_21->name+69)='o';
*(FCNN_2L_W_FBALL_22_21->name+70)='u';
*(FCNN_2L_W_FBALL_22_21->name+71)='g';
*(FCNN_2L_W_FBALL_22_21->name+72)='h';
*(FCNN_2L_W_FBALL_22_21->name+73)='_';
*(FCNN_2L_W_FBALL_22_21->name+74)='W';
*(FCNN_2L_W_FBALL_22_21->name+75)='i';
*(FCNN_2L_W_FBALL_22_21->name+76)='n';
*(FCNN_2L_W_FBALL_22_21->name+77)='d';
*(FCNN_2L_W_FBALL_22_21->name+78)='o';
*(FCNN_2L_W_FBALL_22_21->name+79)='w';
*(FCNN_2L_W_FBALL_22_21->name+80)='_';
*(FCNN_2L_W_FBALL_22_21->name+81)='f';
*(FCNN_2L_W_FBALL_22_21->name+82)='e';
*(FCNN_2L_W_FBALL_22_21->name+83)='e';
*(FCNN_2L_W_FBALL_22_21->name+84)='d';
*(FCNN_2L_W_FBALL_22_21->name+85)='b';
*(FCNN_2L_W_FBALL_22_21->name+86)='a';
*(FCNN_2L_W_FBALL_22_21->name+87)='c';
*(FCNN_2L_W_FBALL_22_21->name+88)='k';
*(FCNN_2L_W_FBALL_22_21->name+89)='_';
*(FCNN_2L_W_FBALL_22_21->name+90)='2';
*(FCNN_2L_W_FBALL_22_21->name+91)='>';
*(FCNN_2L_W_FBALL_22_21->name+92)='2';
*(FCNN_2L_W_FBALL_22_21->name+93)='_';
*(FCNN_2L_W_FBALL_22_21->name+94)='a';
*(FCNN_2L_W_FBALL_22_21->name+95)='n';
*(FCNN_2L_W_FBALL_22_21->name+96)='d';
*(FCNN_2L_W_FBALL_22_21->name+97)='_';
*(FCNN_2L_W_FBALL_22_21->name+98)='2';
*(FCNN_2L_W_FBALL_22_21->name+99)='>';
*(FCNN_2L_W_FBALL_22_21->name+100)='1';
*(FCNN_2L_W_FBALL_22_21->name+101)=')';
*(FCNN_2L_W_FBALL_22_21->name+102)=' ';
FCNN_2L_W_FBALL_22_21->number_of_Levels=2;
FCNN_2L_W_FBALL_22_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_22_21->prepare_input()) as well from feedback */
FCNN_2L_W_FBALL_22_21->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_22_21->number_of_Levels);
*(FCNN_2L_W_FBALL_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_22_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_22_21->recurrence=T;
FCNN_2L_W_FBALL_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_W_FBALL_22_21->source=MAI((long int)FCNN_2L_W_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22_21->source+0)=2;
*(FCNN_2L_W_FBALL_22_21->source+1)=2;
FCNN_2L_W_FBALL_22_21->destination=MAI((long int)FCNN_2L_W_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22_21->destination+0)=2;
*(FCNN_2L_W_FBALL_22_21->destination+1)=1;
FCNN_2L_W_FBALL_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21->create_neuron==0) exit_handling(52,1);
*(FCNN_2L_W_FBALL_22_21->create_neuron+0)=create_FCNN_2L_FBALL_22_21;
FCNN_2L_W_FBALL_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_22_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_22_21->number_linear_output_functions=3;
FCNN_2L_W_FBALL_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21->node_linear_output==0) exit_handling(52,2);
*(FCNN_2L_W_FBALL_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_22_21->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21->node_output==0) exit_handling(52,3);
*(FCNN_2L_W_FBALL_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21->node_output_derivation==0) exit_handling(52,4);
*(FCNN_2L_W_FBALL_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_22_21->number_of_firing_functions=2;
FCNN_2L_W_FBALL_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21->firing_neuron==0) exit_handling(52,5);
*(FCNN_2L_W_FBALL_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FBALL_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FBALL_22_21->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21->create_learning_algorithm==0) exit_handling(52,6);
*(FCNN_2L_W_FBALL_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_22_21);
} /* ; */
/* setting up FCNN_2L_W_FBALL_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FBALL_22_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FBALL_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FBALL_22_21_11;
FCNN_2L_W_FBALL_22_21_11=MANTD((long int)1);
FCNN_2L_W_FBALL_22_21_11->name=MAC((long int)114);
*(FCNN_2L_W_FBALL_22_21_11->name+0)='F';
*(FCNN_2L_W_FBALL_22_21_11->name+1)='C';
*(FCNN_2L_W_FBALL_22_21_11->name+2)='N';
*(FCNN_2L_W_FBALL_22_21_11->name+3)='N';
*(FCNN_2L_W_FBALL_22_21_11->name+4)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+5)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+6)='L';
*(FCNN_2L_W_FBALL_22_21_11->name+7)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+8)='W';
*(FCNN_2L_W_FBALL_22_21_11->name+9)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+10)='F';
*(FCNN_2L_W_FBALL_22_21_11->name+11)='B';
*(FCNN_2L_W_FBALL_22_21_11->name+12)='A';
*(FCNN_2L_W_FBALL_22_21_11->name+13)='L';
*(FCNN_2L_W_FBALL_22_21_11->name+14)='L';
*(FCNN_2L_W_FBALL_22_21_11->name+15)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+16)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+17)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+18)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+19)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+20)='1';
*(FCNN_2L_W_FBALL_22_21_11->name+21)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+22)='1';
*(FCNN_2L_W_FBALL_22_21_11->name+23)='1';
*(FCNN_2L_W_FBALL_22_21_11->name+24)='(';
*(FCNN_2L_W_FBALL_22_21_11->name+25)='F';
*(FCNN_2L_W_FBALL_22_21_11->name+26)='u';
*(FCNN_2L_W_FBALL_22_21_11->name+27)='l';
*(FCNN_2L_W_FBALL_22_21_11->name+28)='l';
*(FCNN_2L_W_FBALL_22_21_11->name+29)='y';
*(FCNN_2L_W_FBALL_22_21_11->name+30)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+31)='C';
*(FCNN_2L_W_FBALL_22_21_11->name+32)='o';
*(FCNN_2L_W_FBALL_22_21_11->name+33)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+34)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+35)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+36)='c';
*(FCNN_2L_W_FBALL_22_21_11->name+37)='t';
*(FCNN_2L_W_FBALL_22_21_11->name+38)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+39)='d';
*(FCNN_2L_W_FBALL_22_21_11->name+40)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+41)='N';
*(FCNN_2L_W_FBALL_22_21_11->name+42)='N';
*(FCNN_2L_W_FBALL_22_21_11->name+43)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+44)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+45)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+46)='L';
*(FCNN_2L_W_FBALL_22_21_11->name+47)='a';
*(FCNN_2L_W_FBALL_22_21_11->name+48)='y';
*(FCNN_2L_W_FBALL_22_21_11->name+49)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+50)='r';
*(FCNN_2L_W_FBALL_22_21_11->name+51)='s';
*(FCNN_2L_W_FBALL_22_21_11->name+52)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+53)='r';
*(FCNN_2L_W_FBALL_22_21_11->name+54)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+55)='c';
*(FCNN_2L_W_FBALL_22_21_11->name+56)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+57)='i';
*(FCNN_2L_W_FBALL_22_21_11->name+58)='v';
*(FCNN_2L_W_FBALL_22_21_11->name+59)='i';
*(FCNN_2L_W_FBALL_22_21_11->name+60)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+61)='g';
*(FCNN_2L_W_FBALL_22_21_11->name+62)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+63)='i';
*(FCNN_2L_W_FBALL_22_21_11->name+64)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+65)='p';
*(FCNN_2L_W_FBALL_22_21_11->name+66)='u';
*(FCNN_2L_W_FBALL_22_21_11->name+67)='t';
*(FCNN_2L_W_FBALL_22_21_11->name+68)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+69)='t';
*(FCNN_2L_W_FBALL_22_21_11->name+70)='h';
*(FCNN_2L_W_FBALL_22_21_11->name+71)='r';
*(FCNN_2L_W_FBALL_22_21_11->name+72)='o';
*(FCNN_2L_W_FBALL_22_21_11->name+73)='u';
*(FCNN_2L_W_FBALL_22_21_11->name+74)='g';
*(FCNN_2L_W_FBALL_22_21_11->name+75)='h';
*(FCNN_2L_W_FBALL_22_21_11->name+76)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+77)='W';
*(FCNN_2L_W_FBALL_22_21_11->name+78)='i';
*(FCNN_2L_W_FBALL_22_21_11->name+79)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+80)='d';
*(FCNN_2L_W_FBALL_22_21_11->name+81)='o';
*(FCNN_2L_W_FBALL_22_21_11->name+82)='w';
*(FCNN_2L_W_FBALL_22_21_11->name+83)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+84)='f';
*(FCNN_2L_W_FBALL_22_21_11->name+85)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+86)='e';
*(FCNN_2L_W_FBALL_22_21_11->name+87)='d';
*(FCNN_2L_W_FBALL_22_21_11->name+88)='b';
*(FCNN_2L_W_FBALL_22_21_11->name+89)='a';
*(FCNN_2L_W_FBALL_22_21_11->name+90)='c';
*(FCNN_2L_W_FBALL_22_21_11->name+91)='k';
*(FCNN_2L_W_FBALL_22_21_11->name+92)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+93)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+94)='>';
*(FCNN_2L_W_FBALL_22_21_11->name+95)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+96)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+97)='a';
*(FCNN_2L_W_FBALL_22_21_11->name+98)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+99)='d';
*(FCNN_2L_W_FBALL_22_21_11->name+100)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+101)='2';
*(FCNN_2L_W_FBALL_22_21_11->name+102)='>';
*(FCNN_2L_W_FBALL_22_21_11->name+103)='1';
*(FCNN_2L_W_FBALL_22_21_11->name+104)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+105)='a';
*(FCNN_2L_W_FBALL_22_21_11->name+106)='n';
*(FCNN_2L_W_FBALL_22_21_11->name+107)='d';
*(FCNN_2L_W_FBALL_22_21_11->name+108)='_';
*(FCNN_2L_W_FBALL_22_21_11->name+109)='1';
*(FCNN_2L_W_FBALL_22_21_11->name+110)='>';
*(FCNN_2L_W_FBALL_22_21_11->name+111)='1';
*(FCNN_2L_W_FBALL_22_21_11->name+112)=')';
*(FCNN_2L_W_FBALL_22_21_11->name+113)=' ';
FCNN_2L_W_FBALL_22_21_11->number_of_Levels=2;
FCNN_2L_W_FBALL_22_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FBALL_22_21_11->prepare_input()) as well from feedback */
FCNN_2L_W_FBALL_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FBALL_22_21_11->number_of_Levels);
*(FCNN_2L_W_FBALL_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FBALL_22_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FBALL_22_21_11->recurrence=T;
FCNN_2L_W_FBALL_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_W_FBALL_22_21_11->source=MAI((long int)FCNN_2L_W_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22_21_11->source+0)=2;
*(FCNN_2L_W_FBALL_22_21_11->source+1)=2;
*(FCNN_2L_W_FBALL_22_21_11->source+2)=1;
FCNN_2L_W_FBALL_22_21_11->destination=MAI((long int)FCNN_2L_W_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FBALL_22_21_11->destination+0)=2;
*(FCNN_2L_W_FBALL_22_21_11->destination+1)=1;
*(FCNN_2L_W_FBALL_22_21_11->destination+2)=1;
FCNN_2L_W_FBALL_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FBALL_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21_11->create_neuron==0) exit_handling(53,1);
*(FCNN_2L_W_FBALL_22_21_11->create_neuron+0)=create_FCNN_2L_FBALL_22_21_11;
FCNN_2L_W_FBALL_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FBALL_22_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FBALL_22_21_11->number_linear_output_functions=3;
FCNN_2L_W_FBALL_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21_11->node_linear_output==0) exit_handling(53,2);
*(FCNN_2L_W_FBALL_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FBALL_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FBALL_22_21_11->number_of_node_output_functions=4;
FCNN_2L_W_FBALL_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21_11->node_output==0) exit_handling(53,3);
*(FCNN_2L_W_FBALL_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FBALL_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FBALL_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FBALL_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FBALL_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21_11->node_output_derivation==0) exit_handling(53,4);
*(FCNN_2L_W_FBALL_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FBALL_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FBALL_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FBALL_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FBALL_22_21_11->number_of_firing_functions=2;
FCNN_2L_W_FBALL_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21_11->firing_neuron==0) exit_handling(53,5);
*(FCNN_2L_W_FBALL_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FBALL_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FBALL_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_FBALL_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FBALL_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FBALL_22_21_11->create_learning_algorithm==0) exit_handling(53,6);
*(FCNN_2L_W_FBALL_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FBALL_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FBALL_22_21_11);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_11;
FCNN_2L_1out_FBALL_11=MANTD((long int)1);
FCNN_2L_1out_FBALL_11->name=MAC((long int)73);
*(FCNN_2L_1out_FBALL_11->name+0)='F';
*(FCNN_2L_1out_FBALL_11->name+1)='C';
*(FCNN_2L_1out_FBALL_11->name+2)='N';
*(FCNN_2L_1out_FBALL_11->name+3)='N';
*(FCNN_2L_1out_FBALL_11->name+4)='_';
*(FCNN_2L_1out_FBALL_11->name+5)='2';
*(FCNN_2L_1out_FBALL_11->name+6)='L';
*(FCNN_2L_1out_FBALL_11->name+7)='_';
*(FCNN_2L_1out_FBALL_11->name+8)='1';
*(FCNN_2L_1out_FBALL_11->name+9)='o';
*(FCNN_2L_1out_FBALL_11->name+10)='u';
*(FCNN_2L_1out_FBALL_11->name+11)='t';
*(FCNN_2L_1out_FBALL_11->name+12)='_';
*(FCNN_2L_1out_FBALL_11->name+13)='F';
*(FCNN_2L_1out_FBALL_11->name+14)='B';
*(FCNN_2L_1out_FBALL_11->name+15)='A';
*(FCNN_2L_1out_FBALL_11->name+16)='L';
*(FCNN_2L_1out_FBALL_11->name+17)='L';
*(FCNN_2L_1out_FBALL_11->name+18)='_';
*(FCNN_2L_1out_FBALL_11->name+19)='1';
*(FCNN_2L_1out_FBALL_11->name+20)='1';
*(FCNN_2L_1out_FBALL_11->name+21)='(';
*(FCNN_2L_1out_FBALL_11->name+22)='F';
*(FCNN_2L_1out_FBALL_11->name+23)='u';
*(FCNN_2L_1out_FBALL_11->name+24)='l';
*(FCNN_2L_1out_FBALL_11->name+25)='l';
*(FCNN_2L_1out_FBALL_11->name+26)='y';
*(FCNN_2L_1out_FBALL_11->name+27)='_';
*(FCNN_2L_1out_FBALL_11->name+28)='C';
*(FCNN_2L_1out_FBALL_11->name+29)='o';
*(FCNN_2L_1out_FBALL_11->name+30)='n';
*(FCNN_2L_1out_FBALL_11->name+31)='n';
*(FCNN_2L_1out_FBALL_11->name+32)='e';
*(FCNN_2L_1out_FBALL_11->name+33)='c';
*(FCNN_2L_1out_FBALL_11->name+34)='t';
*(FCNN_2L_1out_FBALL_11->name+35)='e';
*(FCNN_2L_1out_FBALL_11->name+36)='d';
*(FCNN_2L_1out_FBALL_11->name+37)='_';
*(FCNN_2L_1out_FBALL_11->name+38)='N';
*(FCNN_2L_1out_FBALL_11->name+39)='N';
*(FCNN_2L_1out_FBALL_11->name+40)='_';
*(FCNN_2L_1out_FBALL_11->name+41)='2';
*(FCNN_2L_1out_FBALL_11->name+42)='_';
*(FCNN_2L_1out_FBALL_11->name+43)='L';
*(FCNN_2L_1out_FBALL_11->name+44)='a';
*(FCNN_2L_1out_FBALL_11->name+45)='y';
*(FCNN_2L_1out_FBALL_11->name+46)='e';
*(FCNN_2L_1out_FBALL_11->name+47)='r';
*(FCNN_2L_1out_FBALL_11->name+48)='s';
*(FCNN_2L_1out_FBALL_11->name+49)='_';
*(FCNN_2L_1out_FBALL_11->name+50)='1';
*(FCNN_2L_1out_FBALL_11->name+51)='_';
*(FCNN_2L_1out_FBALL_11->name+52)='o';
*(FCNN_2L_1out_FBALL_11->name+53)='u';
*(FCNN_2L_1out_FBALL_11->name+54)='t';
*(FCNN_2L_1out_FBALL_11->name+55)='p';
*(FCNN_2L_1out_FBALL_11->name+56)='u';
*(FCNN_2L_1out_FBALL_11->name+57)='t';
*(FCNN_2L_1out_FBALL_11->name+58)='_';
*(FCNN_2L_1out_FBALL_11->name+59)='f';
*(FCNN_2L_1out_FBALL_11->name+60)='e';
*(FCNN_2L_1out_FBALL_11->name+61)='e';
*(FCNN_2L_1out_FBALL_11->name+62)='d';
*(FCNN_2L_1out_FBALL_11->name+63)='b';
*(FCNN_2L_1out_FBALL_11->name+64)='a';
*(FCNN_2L_1out_FBALL_11->name+65)='c';
*(FCNN_2L_1out_FBALL_11->name+66)='k';
*(FCNN_2L_1out_FBALL_11->name+67)='_';
*(FCNN_2L_1out_FBALL_11->name+68)='1';
*(FCNN_2L_1out_FBALL_11->name+69)='>';
*(FCNN_2L_1out_FBALL_11->name+70)='1';
*(FCNN_2L_1out_FBALL_11->name+71)=')';
*(FCNN_2L_1out_FBALL_11->name+72)=' ';
FCNN_2L_1out_FBALL_11->number_of_Levels=2;
FCNN_2L_1out_FBALL_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FBALL_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_11->number_of_Levels);
*(FCNN_2L_1out_FBALL_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_11->recurrence=T;
FCNN_2L_1out_FBALL_11->number_of_recurrent_connected_layers=1;
FCNN_2L_1out_FBALL_11->source=MAI((long int)FCNN_2L_1out_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_11->source+0)=1;
FCNN_2L_1out_FBALL_11->destination=MAI((long int)FCNN_2L_1out_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_11->destination+0)=1;
FCNN_2L_1out_FBALL_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_11->create_neuron==0) exit_handling(54,1);
*(FCNN_2L_1out_FBALL_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_11;
FCNN_2L_1out_FBALL_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_11->prepare_input=0;
FCNN_2L_1out_FBALL_11->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_11->node_linear_output==0) exit_handling(54,2);
*(FCNN_2L_1out_FBALL_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_11->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_11->node_output==0) exit_handling(54,3);
*(FCNN_2L_1out_FBALL_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_11->node_output_derivation==0) exit_handling(54,4);
*(FCNN_2L_1out_FBALL_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_11->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_11->firing_neuron==0) exit_handling(54,5);
*(FCNN_2L_1out_FBALL_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FBALL_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FBALL_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_11->create_learning_algorithm==0) exit_handling(54,6);
*(FCNN_2L_1out_FBALL_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_11);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_22 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_22;
FCNN_2L_1out_FBALL_22=MANTD((long int)1);
FCNN_2L_1out_FBALL_22->name=MAC((long int)73);
*(FCNN_2L_1out_FBALL_22->name+0)='F';
*(FCNN_2L_1out_FBALL_22->name+1)='C';
*(FCNN_2L_1out_FBALL_22->name+2)='N';
*(FCNN_2L_1out_FBALL_22->name+3)='N';
*(FCNN_2L_1out_FBALL_22->name+4)='_';
*(FCNN_2L_1out_FBALL_22->name+5)='2';
*(FCNN_2L_1out_FBALL_22->name+6)='L';
*(FCNN_2L_1out_FBALL_22->name+7)='_';
*(FCNN_2L_1out_FBALL_22->name+8)='1';
*(FCNN_2L_1out_FBALL_22->name+9)='o';
*(FCNN_2L_1out_FBALL_22->name+10)='u';
*(FCNN_2L_1out_FBALL_22->name+11)='t';
*(FCNN_2L_1out_FBALL_22->name+12)='_';
*(FCNN_2L_1out_FBALL_22->name+13)='F';
*(FCNN_2L_1out_FBALL_22->name+14)='B';
*(FCNN_2L_1out_FBALL_22->name+15)='A';
*(FCNN_2L_1out_FBALL_22->name+16)='L';
*(FCNN_2L_1out_FBALL_22->name+17)='L';
*(FCNN_2L_1out_FBALL_22->name+18)='_';
*(FCNN_2L_1out_FBALL_22->name+19)='2';
*(FCNN_2L_1out_FBALL_22->name+20)='2';
*(FCNN_2L_1out_FBALL_22->name+21)='(';
*(FCNN_2L_1out_FBALL_22->name+22)='F';
*(FCNN_2L_1out_FBALL_22->name+23)='u';
*(FCNN_2L_1out_FBALL_22->name+24)='l';
*(FCNN_2L_1out_FBALL_22->name+25)='l';
*(FCNN_2L_1out_FBALL_22->name+26)='y';
*(FCNN_2L_1out_FBALL_22->name+27)='_';
*(FCNN_2L_1out_FBALL_22->name+28)='C';
*(FCNN_2L_1out_FBALL_22->name+29)='o';
*(FCNN_2L_1out_FBALL_22->name+30)='n';
*(FCNN_2L_1out_FBALL_22->name+31)='n';
*(FCNN_2L_1out_FBALL_22->name+32)='e';
*(FCNN_2L_1out_FBALL_22->name+33)='c';
*(FCNN_2L_1out_FBALL_22->name+34)='t';
*(FCNN_2L_1out_FBALL_22->name+35)='e';
*(FCNN_2L_1out_FBALL_22->name+36)='d';
*(FCNN_2L_1out_FBALL_22->name+37)='_';
*(FCNN_2L_1out_FBALL_22->name+38)='N';
*(FCNN_2L_1out_FBALL_22->name+39)='N';
*(FCNN_2L_1out_FBALL_22->name+40)='_';
*(FCNN_2L_1out_FBALL_22->name+41)='2';
*(FCNN_2L_1out_FBALL_22->name+42)='_';
*(FCNN_2L_1out_FBALL_22->name+43)='L';
*(FCNN_2L_1out_FBALL_22->name+44)='a';
*(FCNN_2L_1out_FBALL_22->name+45)='y';
*(FCNN_2L_1out_FBALL_22->name+46)='e';
*(FCNN_2L_1out_FBALL_22->name+47)='r';
*(FCNN_2L_1out_FBALL_22->name+48)='s';
*(FCNN_2L_1out_FBALL_22->name+49)='_';
*(FCNN_2L_1out_FBALL_22->name+50)='1';
*(FCNN_2L_1out_FBALL_22->name+51)='_';
*(FCNN_2L_1out_FBALL_22->name+52)='o';
*(FCNN_2L_1out_FBALL_22->name+53)='u';
*(FCNN_2L_1out_FBALL_22->name+54)='t';
*(FCNN_2L_1out_FBALL_22->name+55)='p';
*(FCNN_2L_1out_FBALL_22->name+56)='u';
*(FCNN_2L_1out_FBALL_22->name+57)='t';
*(FCNN_2L_1out_FBALL_22->name+58)='_';
*(FCNN_2L_1out_FBALL_22->name+59)='f';
*(FCNN_2L_1out_FBALL_22->name+60)='e';
*(FCNN_2L_1out_FBALL_22->name+61)='e';
*(FCNN_2L_1out_FBALL_22->name+62)='d';
*(FCNN_2L_1out_FBALL_22->name+63)='b';
*(FCNN_2L_1out_FBALL_22->name+64)='a';
*(FCNN_2L_1out_FBALL_22->name+65)='c';
*(FCNN_2L_1out_FBALL_22->name+66)='k';
*(FCNN_2L_1out_FBALL_22->name+67)='_';
*(FCNN_2L_1out_FBALL_22->name+68)='2';
*(FCNN_2L_1out_FBALL_22->name+69)='>';
*(FCNN_2L_1out_FBALL_22->name+70)='2';
*(FCNN_2L_1out_FBALL_22->name+71)=')';
*(FCNN_2L_1out_FBALL_22->name+72)=' ';
FCNN_2L_1out_FBALL_22->number_of_Levels=2;
FCNN_2L_1out_FBALL_22->inputs_per_first_Level_node=2; /* means all inputs are associated with all 1st Level nodes */
FCNN_2L_1out_FBALL_22->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_22->number_of_Levels);
*(FCNN_2L_1out_FBALL_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_22->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_22->recurrence=T;
FCNN_2L_1out_FBALL_22->number_of_recurrent_connected_layers=1;
FCNN_2L_1out_FBALL_22->source=MAI((long int)FCNN_2L_1out_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22->source+0)=2;
FCNN_2L_1out_FBALL_22->destination=MAI((long int)FCNN_2L_1out_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22->destination+0)=2;
FCNN_2L_1out_FBALL_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_22->create_neuron==0) exit_handling(55,1);
*(FCNN_2L_1out_FBALL_22->create_neuron+0)=create_FCNN_2L_1out_FBALL_22;
FCNN_2L_1out_FBALL_22->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_22->prepare_input=0;
FCNN_2L_1out_FBALL_22->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22->node_linear_output==0) exit_handling(55,2);
*(FCNN_2L_1out_FBALL_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_22->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_22->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22->node_output==0) exit_handling(55,3);
*(FCNN_2L_1out_FBALL_22->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22->node_output_derivation==0) exit_handling(55,4);
*(FCNN_2L_1out_FBALL_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_22->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22->firing_neuron==0) exit_handling(55,5);
*(FCNN_2L_1out_FBALL_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FBALL_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FBALL_22->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_22->create_learning_algorithm==0) exit_handling(55,6);
*(FCNN_2L_1out_FBALL_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_22);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_21 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto the 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_21;
FCNN_2L_1out_FBALL_21=MANTD((long int)1);
FCNN_2L_1out_FBALL_21->name=MAC((long int)73);
*(FCNN_2L_1out_FBALL_21->name+0)='F';
*(FCNN_2L_1out_FBALL_21->name+1)='C';
*(FCNN_2L_1out_FBALL_21->name+2)='N';
*(FCNN_2L_1out_FBALL_21->name+3)='N';
*(FCNN_2L_1out_FBALL_21->name+4)='_';
*(FCNN_2L_1out_FBALL_21->name+5)='2';
*(FCNN_2L_1out_FBALL_21->name+6)='L';
*(FCNN_2L_1out_FBALL_21->name+7)='_';
*(FCNN_2L_1out_FBALL_21->name+8)='1';
*(FCNN_2L_1out_FBALL_21->name+9)='o';
*(FCNN_2L_1out_FBALL_21->name+10)='u';
*(FCNN_2L_1out_FBALL_21->name+11)='t';
*(FCNN_2L_1out_FBALL_21->name+12)='_';
*(FCNN_2L_1out_FBALL_21->name+13)='F';
*(FCNN_2L_1out_FBALL_21->name+14)='B';
*(FCNN_2L_1out_FBALL_21->name+15)='A';
*(FCNN_2L_1out_FBALL_21->name+16)='L';
*(FCNN_2L_1out_FBALL_21->name+17)='L';
*(FCNN_2L_1out_FBALL_21->name+18)='_';
*(FCNN_2L_1out_FBALL_21->name+19)='2';
*(FCNN_2L_1out_FBALL_21->name+20)='1';
*(FCNN_2L_1out_FBALL_21->name+21)='(';
*(FCNN_2L_1out_FBALL_21->name+22)='F';
*(FCNN_2L_1out_FBALL_21->name+23)='u';
*(FCNN_2L_1out_FBALL_21->name+24)='l';
*(FCNN_2L_1out_FBALL_21->name+25)='l';
*(FCNN_2L_1out_FBALL_21->name+26)='y';
*(FCNN_2L_1out_FBALL_21->name+27)='_';
*(FCNN_2L_1out_FBALL_21->name+28)='C';
*(FCNN_2L_1out_FBALL_21->name+29)='o';
*(FCNN_2L_1out_FBALL_21->name+30)='n';
*(FCNN_2L_1out_FBALL_21->name+31)='n';
*(FCNN_2L_1out_FBALL_21->name+32)='e';
*(FCNN_2L_1out_FBALL_21->name+33)='c';
*(FCNN_2L_1out_FBALL_21->name+34)='t';
*(FCNN_2L_1out_FBALL_21->name+35)='e';
*(FCNN_2L_1out_FBALL_21->name+36)='d';
*(FCNN_2L_1out_FBALL_21->name+37)='_';
*(FCNN_2L_1out_FBALL_21->name+38)='N';
*(FCNN_2L_1out_FBALL_21->name+39)='N';
*(FCNN_2L_1out_FBALL_21->name+40)='_';
*(FCNN_2L_1out_FBALL_21->name+41)='2';
*(FCNN_2L_1out_FBALL_21->name+42)='_';
*(FCNN_2L_1out_FBALL_21->name+43)='L';
*(FCNN_2L_1out_FBALL_21->name+44)='a';
*(FCNN_2L_1out_FBALL_21->name+45)='y';
*(FCNN_2L_1out_FBALL_21->name+46)='e';
*(FCNN_2L_1out_FBALL_21->name+47)='r';
*(FCNN_2L_1out_FBALL_21->name+48)='s';
*(FCNN_2L_1out_FBALL_21->name+49)='_';
*(FCNN_2L_1out_FBALL_21->name+50)='1';
*(FCNN_2L_1out_FBALL_21->name+51)='_';
*(FCNN_2L_1out_FBALL_21->name+52)='o';
*(FCNN_2L_1out_FBALL_21->name+53)='u';
*(FCNN_2L_1out_FBALL_21->name+54)='t';
*(FCNN_2L_1out_FBALL_21->name+55)='p';
*(FCNN_2L_1out_FBALL_21->name+56)='u';
*(FCNN_2L_1out_FBALL_21->name+57)='t';
*(FCNN_2L_1out_FBALL_21->name+58)='_';
*(FCNN_2L_1out_FBALL_21->name+59)='f';
*(FCNN_2L_1out_FBALL_21->name+60)='e';
*(FCNN_2L_1out_FBALL_21->name+61)='e';
*(FCNN_2L_1out_FBALL_21->name+62)='d';
*(FCNN_2L_1out_FBALL_21->name+63)='b';
*(FCNN_2L_1out_FBALL_21->name+64)='a';
*(FCNN_2L_1out_FBALL_21->name+65)='c';
*(FCNN_2L_1out_FBALL_21->name+66)='k';
*(FCNN_2L_1out_FBALL_21->name+67)='_';
*(FCNN_2L_1out_FBALL_21->name+68)='2';
*(FCNN_2L_1out_FBALL_21->name+69)='>';
*(FCNN_2L_1out_FBALL_21->name+70)='1';
*(FCNN_2L_1out_FBALL_21->name+71)=')';
*(FCNN_2L_1out_FBALL_21->name+72)=' ';
FCNN_2L_1out_FBALL_21->number_of_Levels=2;
FCNN_2L_1out_FBALL_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FBALL_21->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_21->number_of_Levels);
*(FCNN_2L_1out_FBALL_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_21->recurrence=T;
FCNN_2L_1out_FBALL_21->number_of_recurrent_connected_layers=1;
FCNN_2L_1out_FBALL_21->source=MAI((long int)FCNN_2L_1out_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_21->source+0)=2;
FCNN_2L_1out_FBALL_21->destination=MAI((long int)FCNN_2L_1out_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_21->destination+0)=1;
FCNN_2L_1out_FBALL_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_21->create_neuron==0) exit_handling(56,1);
*(FCNN_2L_1out_FBALL_21->create_neuron+0)=create_FCNN_2L_1out_FBALL_21;
FCNN_2L_1out_FBALL_21->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_21->prepare_input=0;
FCNN_2L_1out_FBALL_21->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21->node_linear_output==0) exit_handling(56,2);
*(FCNN_2L_1out_FBALL_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_21->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_21->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21->node_output==0) exit_handling(56,3);
*(FCNN_2L_1out_FBALL_21->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21->node_output_derivation==0) exit_handling(56,4);
*(FCNN_2L_1out_FBALL_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_21->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21->firing_neuron==0) exit_handling(56,5);
*(FCNN_2L_1out_FBALL_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_1out_FBALL_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_1out_FBALL_21->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_21->create_learning_algorithm==0) exit_handling(56,6);
*(FCNN_2L_1out_FBALL_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_21);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_22_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_22_11;
FCNN_2L_1out_FBALL_22_11=MANTD((long int)1);
FCNN_2L_1out_FBALL_22_11->name=MAC((long int)80);
*(FCNN_2L_1out_FBALL_22_11->name+0)='F';
*(FCNN_2L_1out_FBALL_22_11->name+1)='C';
*(FCNN_2L_1out_FBALL_22_11->name+2)='N';
*(FCNN_2L_1out_FBALL_22_11->name+3)='N';
*(FCNN_2L_1out_FBALL_22_11->name+4)='_';
*(FCNN_2L_1out_FBALL_22_11->name+5)='2';
*(FCNN_2L_1out_FBALL_22_11->name+6)='L';
*(FCNN_2L_1out_FBALL_22_11->name+7)='_';
*(FCNN_2L_1out_FBALL_22_11->name+8)='1';
*(FCNN_2L_1out_FBALL_22_11->name+9)='o';
*(FCNN_2L_1out_FBALL_22_11->name+10)='u';
*(FCNN_2L_1out_FBALL_22_11->name+11)='t';
*(FCNN_2L_1out_FBALL_22_11->name+12)='_';
*(FCNN_2L_1out_FBALL_22_11->name+13)='F';
*(FCNN_2L_1out_FBALL_22_11->name+14)='B';
*(FCNN_2L_1out_FBALL_22_11->name+15)='A';
*(FCNN_2L_1out_FBALL_22_11->name+16)='L';
*(FCNN_2L_1out_FBALL_22_11->name+17)='L';
*(FCNN_2L_1out_FBALL_22_11->name+18)='_';
*(FCNN_2L_1out_FBALL_22_11->name+19)='2';
*(FCNN_2L_1out_FBALL_22_11->name+20)='2';
*(FCNN_2L_1out_FBALL_22_11->name+21)='_';
*(FCNN_2L_1out_FBALL_22_11->name+22)='1';
*(FCNN_2L_1out_FBALL_22_11->name+23)='1';
*(FCNN_2L_1out_FBALL_22_11->name+24)='(';
*(FCNN_2L_1out_FBALL_22_11->name+25)='F';
*(FCNN_2L_1out_FBALL_22_11->name+26)='u';
*(FCNN_2L_1out_FBALL_22_11->name+27)='l';
*(FCNN_2L_1out_FBALL_22_11->name+28)='l';
*(FCNN_2L_1out_FBALL_22_11->name+29)='y';
*(FCNN_2L_1out_FBALL_22_11->name+30)='_';
*(FCNN_2L_1out_FBALL_22_11->name+31)='C';
*(FCNN_2L_1out_FBALL_22_11->name+32)='o';
*(FCNN_2L_1out_FBALL_22_11->name+33)='n';
*(FCNN_2L_1out_FBALL_22_11->name+34)='n';
*(FCNN_2L_1out_FBALL_22_11->name+35)='e';
*(FCNN_2L_1out_FBALL_22_11->name+36)='c';
*(FCNN_2L_1out_FBALL_22_11->name+37)='t';
*(FCNN_2L_1out_FBALL_22_11->name+38)='e';
*(FCNN_2L_1out_FBALL_22_11->name+39)='d';
*(FCNN_2L_1out_FBALL_22_11->name+40)='_';
*(FCNN_2L_1out_FBALL_22_11->name+41)='N';
*(FCNN_2L_1out_FBALL_22_11->name+42)='N';
*(FCNN_2L_1out_FBALL_22_11->name+43)='_';
*(FCNN_2L_1out_FBALL_22_11->name+44)='2';
*(FCNN_2L_1out_FBALL_22_11->name+45)='_';
*(FCNN_2L_1out_FBALL_22_11->name+46)='L';
*(FCNN_2L_1out_FBALL_22_11->name+47)='a';
*(FCNN_2L_1out_FBALL_22_11->name+48)='y';
*(FCNN_2L_1out_FBALL_22_11->name+49)='e';
*(FCNN_2L_1out_FBALL_22_11->name+50)='r';
*(FCNN_2L_1out_FBALL_22_11->name+51)='s';
*(FCNN_2L_1out_FBALL_22_11->name+52)='_';
*(FCNN_2L_1out_FBALL_22_11->name+53)='1';
*(FCNN_2L_1out_FBALL_22_11->name+54)='_';
*(FCNN_2L_1out_FBALL_22_11->name+55)='o';
*(FCNN_2L_1out_FBALL_22_11->name+56)='u';
*(FCNN_2L_1out_FBALL_22_11->name+57)='t';
*(FCNN_2L_1out_FBALL_22_11->name+58)='p';
*(FCNN_2L_1out_FBALL_22_11->name+59)='u';
*(FCNN_2L_1out_FBALL_22_11->name+60)='t';
*(FCNN_2L_1out_FBALL_22_11->name+61)='_';
*(FCNN_2L_1out_FBALL_22_11->name+62)='f';
*(FCNN_2L_1out_FBALL_22_11->name+63)='e';
*(FCNN_2L_1out_FBALL_22_11->name+64)='e';
*(FCNN_2L_1out_FBALL_22_11->name+65)='d';
*(FCNN_2L_1out_FBALL_22_11->name+66)='b';
*(FCNN_2L_1out_FBALL_22_11->name+67)='a';
*(FCNN_2L_1out_FBALL_22_11->name+68)='c';
*(FCNN_2L_1out_FBALL_22_11->name+69)='k';
*(FCNN_2L_1out_FBALL_22_11->name+70)='_';
*(FCNN_2L_1out_FBALL_22_11->name+71)='2';
*(FCNN_2L_1out_FBALL_22_11->name+72)='>';
*(FCNN_2L_1out_FBALL_22_11->name+73)='2';
*(FCNN_2L_1out_FBALL_22_11->name+74)='_';
*(FCNN_2L_1out_FBALL_22_11->name+75)='1';
*(FCNN_2L_1out_FBALL_22_11->name+76)='>';
*(FCNN_2L_1out_FBALL_22_11->name+77)='1';
*(FCNN_2L_1out_FBALL_22_11->name+78)=')';
*(FCNN_2L_1out_FBALL_22_11->name+79)=' ';
FCNN_2L_1out_FBALL_22_11->number_of_Levels=2;
FCNN_2L_1out_FBALL_22_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FBALL_22_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_22_11->number_of_Levels);
*(FCNN_2L_1out_FBALL_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_22_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_22_11->recurrence=T;
FCNN_2L_1out_FBALL_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_1out_FBALL_22_11->source=MAI((long int)FCNN_2L_1out_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22_11->source+0)=2;
*(FCNN_2L_1out_FBALL_22_11->source+1)=1;
FCNN_2L_1out_FBALL_22_11->destination=MAI((long int)FCNN_2L_1out_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22_11->destination+0)=2;
*(FCNN_2L_1out_FBALL_22_11->destination+1)=1;
FCNN_2L_1out_FBALL_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_11->create_neuron==0) exit_handling(57,1);
*(FCNN_2L_1out_FBALL_22_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_22_11;
FCNN_2L_1out_FBALL_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_22_11->prepare_input=0;
FCNN_2L_1out_FBALL_22_11->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_11->node_linear_output==0) exit_handling(57,2);
*(FCNN_2L_1out_FBALL_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_22_11->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_11->node_output==0) exit_handling(57,3);
*(FCNN_2L_1out_FBALL_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_11->node_output_derivation==0) exit_handling(57,4);
*(FCNN_2L_1out_FBALL_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_22_11->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_11->firing_neuron==0) exit_handling(57,5);
*(FCNN_2L_1out_FBALL_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FBALL_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FBALL_22_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_11->create_learning_algorithm==0) exit_handling(57,6);
*(FCNN_2L_1out_FBALL_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_22_11);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_21_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_21_11;
FCNN_2L_1out_FBALL_21_11=MANTD((long int)1);
FCNN_2L_1out_FBALL_21_11->name=MAC((long int)80);
*(FCNN_2L_1out_FBALL_21_11->name+0)='F';
*(FCNN_2L_1out_FBALL_21_11->name+1)='C';
*(FCNN_2L_1out_FBALL_21_11->name+2)='N';
*(FCNN_2L_1out_FBALL_21_11->name+3)='N';
*(FCNN_2L_1out_FBALL_21_11->name+4)='_';
*(FCNN_2L_1out_FBALL_21_11->name+5)='2';
*(FCNN_2L_1out_FBALL_21_11->name+6)='L';
*(FCNN_2L_1out_FBALL_21_11->name+7)='_';
*(FCNN_2L_1out_FBALL_21_11->name+8)='1';
*(FCNN_2L_1out_FBALL_21_11->name+9)='o';
*(FCNN_2L_1out_FBALL_21_11->name+10)='u';
*(FCNN_2L_1out_FBALL_21_11->name+11)='t';
*(FCNN_2L_1out_FBALL_21_11->name+12)='_';
*(FCNN_2L_1out_FBALL_21_11->name+13)='F';
*(FCNN_2L_1out_FBALL_21_11->name+14)='B';
*(FCNN_2L_1out_FBALL_21_11->name+15)='A';
*(FCNN_2L_1out_FBALL_21_11->name+16)='L';
*(FCNN_2L_1out_FBALL_21_11->name+17)='L';
*(FCNN_2L_1out_FBALL_21_11->name+18)='_';
*(FCNN_2L_1out_FBALL_21_11->name+19)='2';
*(FCNN_2L_1out_FBALL_21_11->name+20)='1';
*(FCNN_2L_1out_FBALL_21_11->name+21)='_';
*(FCNN_2L_1out_FBALL_21_11->name+22)='1';
*(FCNN_2L_1out_FBALL_21_11->name+23)='1';
*(FCNN_2L_1out_FBALL_21_11->name+24)='(';
*(FCNN_2L_1out_FBALL_21_11->name+25)='F';
*(FCNN_2L_1out_FBALL_21_11->name+26)='u';
*(FCNN_2L_1out_FBALL_21_11->name+27)='l';
*(FCNN_2L_1out_FBALL_21_11->name+28)='l';
*(FCNN_2L_1out_FBALL_21_11->name+29)='y';
*(FCNN_2L_1out_FBALL_21_11->name+30)='_';
*(FCNN_2L_1out_FBALL_21_11->name+31)='C';
*(FCNN_2L_1out_FBALL_21_11->name+32)='o';
*(FCNN_2L_1out_FBALL_21_11->name+33)='n';
*(FCNN_2L_1out_FBALL_21_11->name+34)='n';
*(FCNN_2L_1out_FBALL_21_11->name+35)='e';
*(FCNN_2L_1out_FBALL_21_11->name+36)='c';
*(FCNN_2L_1out_FBALL_21_11->name+37)='t';
*(FCNN_2L_1out_FBALL_21_11->name+38)='e';
*(FCNN_2L_1out_FBALL_21_11->name+39)='d';
*(FCNN_2L_1out_FBALL_21_11->name+40)='_';
*(FCNN_2L_1out_FBALL_21_11->name+41)='N';
*(FCNN_2L_1out_FBALL_21_11->name+42)='N';
*(FCNN_2L_1out_FBALL_21_11->name+43)='_';
*(FCNN_2L_1out_FBALL_21_11->name+44)='2';
*(FCNN_2L_1out_FBALL_21_11->name+45)='_';
*(FCNN_2L_1out_FBALL_21_11->name+46)='L';
*(FCNN_2L_1out_FBALL_21_11->name+47)='a';
*(FCNN_2L_1out_FBALL_21_11->name+48)='y';
*(FCNN_2L_1out_FBALL_21_11->name+49)='e';
*(FCNN_2L_1out_FBALL_21_11->name+50)='r';
*(FCNN_2L_1out_FBALL_21_11->name+51)='s';
*(FCNN_2L_1out_FBALL_21_11->name+52)='_';
*(FCNN_2L_1out_FBALL_21_11->name+53)='1';
*(FCNN_2L_1out_FBALL_21_11->name+54)='_';
*(FCNN_2L_1out_FBALL_21_11->name+55)='o';
*(FCNN_2L_1out_FBALL_21_11->name+56)='u';
*(FCNN_2L_1out_FBALL_21_11->name+57)='t';
*(FCNN_2L_1out_FBALL_21_11->name+58)='p';
*(FCNN_2L_1out_FBALL_21_11->name+59)='u';
*(FCNN_2L_1out_FBALL_21_11->name+60)='t';
*(FCNN_2L_1out_FBALL_21_11->name+61)='_';
*(FCNN_2L_1out_FBALL_21_11->name+62)='f';
*(FCNN_2L_1out_FBALL_21_11->name+63)='e';
*(FCNN_2L_1out_FBALL_21_11->name+64)='e';
*(FCNN_2L_1out_FBALL_21_11->name+65)='d';
*(FCNN_2L_1out_FBALL_21_11->name+66)='b';
*(FCNN_2L_1out_FBALL_21_11->name+67)='a';
*(FCNN_2L_1out_FBALL_21_11->name+68)='c';
*(FCNN_2L_1out_FBALL_21_11->name+69)='k';
*(FCNN_2L_1out_FBALL_21_11->name+70)='_';
*(FCNN_2L_1out_FBALL_21_11->name+71)='2';
*(FCNN_2L_1out_FBALL_21_11->name+72)='>';
*(FCNN_2L_1out_FBALL_21_11->name+73)='1';
*(FCNN_2L_1out_FBALL_21_11->name+74)='_';
*(FCNN_2L_1out_FBALL_21_11->name+75)='1';
*(FCNN_2L_1out_FBALL_21_11->name+76)='>';
*(FCNN_2L_1out_FBALL_21_11->name+77)='1';
*(FCNN_2L_1out_FBALL_21_11->name+78)=')';
*(FCNN_2L_1out_FBALL_21_11->name+79)=' ';
FCNN_2L_1out_FBALL_21_11->number_of_Levels=2;
FCNN_2L_1out_FBALL_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedbacks */
FCNN_2L_1out_FBALL_21_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_21_11->number_of_Levels);
*(FCNN_2L_1out_FBALL_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_21_11->recurrence=T;
FCNN_2L_1out_FBALL_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_1out_FBALL_21_11->source=MAI((long int)FCNN_2L_1out_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_21_11->source+0)=2;
*(FCNN_2L_1out_FBALL_21_11->source+1)=1;
FCNN_2L_1out_FBALL_21_11->destination=MAI((long int)FCNN_2L_1out_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_21_11->destination+0)=1;
*(FCNN_2L_1out_FBALL_21_11->destination+1)=1;
FCNN_2L_1out_FBALL_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_21_11->create_neuron==0) exit_handling(58,1);
*(FCNN_2L_1out_FBALL_21_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_21_11;
FCNN_2L_1out_FBALL_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_21_11->prepare_input=0;
FCNN_2L_1out_FBALL_21_11->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21_11->node_linear_output==0) exit_handling(58,2);
*(FCNN_2L_1out_FBALL_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_21_11->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21_11->node_output==0) exit_handling(58,3);
*(FCNN_2L_1out_FBALL_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21_11->node_output_derivation==0) exit_handling(58,4);
*(FCNN_2L_1out_FBALL_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_21_11->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_21_11->firing_neuron==0) exit_handling(58,5);
*(FCNN_2L_1out_FBALL_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FBALL_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FBALL_21_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_21_11->create_learning_algorithm==0) exit_handling(58,6);
*(FCNN_2L_1out_FBALL_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_21_11);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_22_21 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_22_21;
FCNN_2L_1out_FBALL_22_21=MANTD((long int)1);
FCNN_2L_1out_FBALL_22_21->name=MAC((long int)80);
*(FCNN_2L_1out_FBALL_22_21->name+0)='F';
*(FCNN_2L_1out_FBALL_22_21->name+1)='C';
*(FCNN_2L_1out_FBALL_22_21->name+2)='N';
*(FCNN_2L_1out_FBALL_22_21->name+3)='N';
*(FCNN_2L_1out_FBALL_22_21->name+4)='_';
*(FCNN_2L_1out_FBALL_22_21->name+5)='2';
*(FCNN_2L_1out_FBALL_22_21->name+6)='L';
*(FCNN_2L_1out_FBALL_22_21->name+7)='_';
*(FCNN_2L_1out_FBALL_22_21->name+8)='1';
*(FCNN_2L_1out_FBALL_22_21->name+9)='o';
*(FCNN_2L_1out_FBALL_22_21->name+10)='u';
*(FCNN_2L_1out_FBALL_22_21->name+11)='t';
*(FCNN_2L_1out_FBALL_22_21->name+12)='_';
*(FCNN_2L_1out_FBALL_22_21->name+13)='F';
*(FCNN_2L_1out_FBALL_22_21->name+14)='B';
*(FCNN_2L_1out_FBALL_22_21->name+15)='A';
*(FCNN_2L_1out_FBALL_22_21->name+16)='L';
*(FCNN_2L_1out_FBALL_22_21->name+17)='L';
*(FCNN_2L_1out_FBALL_22_21->name+18)='_';
*(FCNN_2L_1out_FBALL_22_21->name+19)='2';
*(FCNN_2L_1out_FBALL_22_21->name+20)='2';
*(FCNN_2L_1out_FBALL_22_21->name+21)='_';
*(FCNN_2L_1out_FBALL_22_21->name+22)='2';
*(FCNN_2L_1out_FBALL_22_21->name+23)='1';
*(FCNN_2L_1out_FBALL_22_21->name+24)='(';
*(FCNN_2L_1out_FBALL_22_21->name+25)='F';
*(FCNN_2L_1out_FBALL_22_21->name+26)='u';
*(FCNN_2L_1out_FBALL_22_21->name+27)='l';
*(FCNN_2L_1out_FBALL_22_21->name+28)='l';
*(FCNN_2L_1out_FBALL_22_21->name+29)='y';
*(FCNN_2L_1out_FBALL_22_21->name+30)='_';
*(FCNN_2L_1out_FBALL_22_21->name+31)='C';
*(FCNN_2L_1out_FBALL_22_21->name+32)='o';
*(FCNN_2L_1out_FBALL_22_21->name+33)='n';
*(FCNN_2L_1out_FBALL_22_21->name+34)='n';
*(FCNN_2L_1out_FBALL_22_21->name+35)='e';
*(FCNN_2L_1out_FBALL_22_21->name+36)='c';
*(FCNN_2L_1out_FBALL_22_21->name+37)='t';
*(FCNN_2L_1out_FBALL_22_21->name+38)='e';
*(FCNN_2L_1out_FBALL_22_21->name+39)='d';
*(FCNN_2L_1out_FBALL_22_21->name+40)='_';
*(FCNN_2L_1out_FBALL_22_21->name+41)='N';
*(FCNN_2L_1out_FBALL_22_21->name+42)='N';
*(FCNN_2L_1out_FBALL_22_21->name+43)='_';
*(FCNN_2L_1out_FBALL_22_21->name+44)='2';
*(FCNN_2L_1out_FBALL_22_21->name+45)='_';
*(FCNN_2L_1out_FBALL_22_21->name+46)='L';
*(FCNN_2L_1out_FBALL_22_21->name+47)='a';
*(FCNN_2L_1out_FBALL_22_21->name+48)='y';
*(FCNN_2L_1out_FBALL_22_21->name+49)='e';
*(FCNN_2L_1out_FBALL_22_21->name+50)='r';
*(FCNN_2L_1out_FBALL_22_21->name+51)='s';
*(FCNN_2L_1out_FBALL_22_21->name+52)='_';
*(FCNN_2L_1out_FBALL_22_21->name+53)='1';
*(FCNN_2L_1out_FBALL_22_21->name+54)='_';
*(FCNN_2L_1out_FBALL_22_21->name+55)='o';
*(FCNN_2L_1out_FBALL_22_21->name+56)='u';
*(FCNN_2L_1out_FBALL_22_21->name+57)='t';
*(FCNN_2L_1out_FBALL_22_21->name+58)='p';
*(FCNN_2L_1out_FBALL_22_21->name+59)='u';
*(FCNN_2L_1out_FBALL_22_21->name+60)='t';
*(FCNN_2L_1out_FBALL_22_21->name+61)='_';
*(FCNN_2L_1out_FBALL_22_21->name+62)='f';
*(FCNN_2L_1out_FBALL_22_21->name+63)='e';
*(FCNN_2L_1out_FBALL_22_21->name+64)='e';
*(FCNN_2L_1out_FBALL_22_21->name+65)='d';
*(FCNN_2L_1out_FBALL_22_21->name+66)='b';
*(FCNN_2L_1out_FBALL_22_21->name+67)='a';
*(FCNN_2L_1out_FBALL_22_21->name+68)='c';
*(FCNN_2L_1out_FBALL_22_21->name+69)='k';
*(FCNN_2L_1out_FBALL_22_21->name+70)='_';
*(FCNN_2L_1out_FBALL_22_21->name+71)='2';
*(FCNN_2L_1out_FBALL_22_21->name+72)='>';
*(FCNN_2L_1out_FBALL_22_21->name+73)='2';
*(FCNN_2L_1out_FBALL_22_21->name+74)='_';
*(FCNN_2L_1out_FBALL_22_21->name+75)='2';
*(FCNN_2L_1out_FBALL_22_21->name+76)='>';
*(FCNN_2L_1out_FBALL_22_21->name+77)='1';
*(FCNN_2L_1out_FBALL_22_21->name+78)=')';
*(FCNN_2L_1out_FBALL_22_21->name+79)=' ';
FCNN_2L_1out_FBALL_22_21->number_of_Levels=2;
FCNN_2L_1out_FBALL_22_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FBALL_22_21->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_22_21->number_of_Levels);
*(FCNN_2L_1out_FBALL_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_22_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_22_21->recurrence=T;
FCNN_2L_1out_FBALL_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_1out_FBALL_22_21->source=MAI((long int)FCNN_2L_1out_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22_21->source+0)=2;
*(FCNN_2L_1out_FBALL_22_21->source+1)=2;
FCNN_2L_1out_FBALL_22_21->destination=MAI((long int)FCNN_2L_1out_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22_21->destination+0)=2;
*(FCNN_2L_1out_FBALL_22_21->destination+1)=1;
FCNN_2L_1out_FBALL_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21->create_neuron==0) exit_handling(59,1);
*(FCNN_2L_1out_FBALL_22_21->create_neuron+0)=create_FCNN_2L_1out_FBALL_22_21;
FCNN_2L_1out_FBALL_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_22_21->prepare_input=0;
FCNN_2L_1out_FBALL_22_21->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21->node_linear_output==0) exit_handling(59,2);
*(FCNN_2L_1out_FBALL_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_22_21->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21->node_output==0) exit_handling(59,3);
*(FCNN_2L_1out_FBALL_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21->node_output_derivation==0) exit_handling(59,4);
*(FCNN_2L_1out_FBALL_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_22_21->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21->firing_neuron==0) exit_handling(59,5);
*(FCNN_2L_1out_FBALL_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FBALL_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FBALL_22_21->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21->create_learning_algorithm==0) exit_handling(59,6);
*(FCNN_2L_1out_FBALL_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_22_21);
} /* ; */
/* setting up FCNN_2L_1out_FBALL_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FBALL_22_21_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FBALL_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FBALL_22_21_11;
FCNN_2L_1out_FBALL_22_21_11=MANTD((long int)1);
FCNN_2L_1out_FBALL_22_21_11->name=MAC((long int)87);
*(FCNN_2L_1out_FBALL_22_21_11->name+0)='F';
*(FCNN_2L_1out_FBALL_22_21_11->name+1)='C';
*(FCNN_2L_1out_FBALL_22_21_11->name+2)='N';
*(FCNN_2L_1out_FBALL_22_21_11->name+3)='N';
*(FCNN_2L_1out_FBALL_22_21_11->name+4)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+5)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+6)='L';
*(FCNN_2L_1out_FBALL_22_21_11->name+7)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+8)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+9)='o';
*(FCNN_2L_1out_FBALL_22_21_11->name+10)='u';
*(FCNN_2L_1out_FBALL_22_21_11->name+11)='t';
*(FCNN_2L_1out_FBALL_22_21_11->name+12)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+13)='F';
*(FCNN_2L_1out_FBALL_22_21_11->name+14)='B';
*(FCNN_2L_1out_FBALL_22_21_11->name+15)='A';
*(FCNN_2L_1out_FBALL_22_21_11->name+16)='L';
*(FCNN_2L_1out_FBALL_22_21_11->name+17)='L';
*(FCNN_2L_1out_FBALL_22_21_11->name+18)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+19)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+20)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+21)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+22)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+23)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+24)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+25)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+26)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+27)='(';
*(FCNN_2L_1out_FBALL_22_21_11->name+28)='F';
*(FCNN_2L_1out_FBALL_22_21_11->name+29)='u';
*(FCNN_2L_1out_FBALL_22_21_11->name+30)='l';
*(FCNN_2L_1out_FBALL_22_21_11->name+31)='l';
*(FCNN_2L_1out_FBALL_22_21_11->name+32)='y';
*(FCNN_2L_1out_FBALL_22_21_11->name+33)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+34)='C';
*(FCNN_2L_1out_FBALL_22_21_11->name+35)='o';
*(FCNN_2L_1out_FBALL_22_21_11->name+36)='n';
*(FCNN_2L_1out_FBALL_22_21_11->name+37)='n';
*(FCNN_2L_1out_FBALL_22_21_11->name+38)='e';
*(FCNN_2L_1out_FBALL_22_21_11->name+39)='c';
*(FCNN_2L_1out_FBALL_22_21_11->name+40)='t';
*(FCNN_2L_1out_FBALL_22_21_11->name+41)='e';
*(FCNN_2L_1out_FBALL_22_21_11->name+42)='d';
*(FCNN_2L_1out_FBALL_22_21_11->name+43)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+44)='N';
*(FCNN_2L_1out_FBALL_22_21_11->name+45)='N';
*(FCNN_2L_1out_FBALL_22_21_11->name+46)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+47)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+48)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+49)='L';
*(FCNN_2L_1out_FBALL_22_21_11->name+50)='a';
*(FCNN_2L_1out_FBALL_22_21_11->name+51)='y';
*(FCNN_2L_1out_FBALL_22_21_11->name+52)='e';
*(FCNN_2L_1out_FBALL_22_21_11->name+53)='r';
*(FCNN_2L_1out_FBALL_22_21_11->name+54)='s';
*(FCNN_2L_1out_FBALL_22_21_11->name+55)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+56)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+57)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+58)='o';
*(FCNN_2L_1out_FBALL_22_21_11->name+59)='u';
*(FCNN_2L_1out_FBALL_22_21_11->name+60)='t';
*(FCNN_2L_1out_FBALL_22_21_11->name+61)='p';
*(FCNN_2L_1out_FBALL_22_21_11->name+62)='u';
*(FCNN_2L_1out_FBALL_22_21_11->name+63)='t';
*(FCNN_2L_1out_FBALL_22_21_11->name+64)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+65)='f';
*(FCNN_2L_1out_FBALL_22_21_11->name+66)='e';
*(FCNN_2L_1out_FBALL_22_21_11->name+67)='e';
*(FCNN_2L_1out_FBALL_22_21_11->name+68)='d';
*(FCNN_2L_1out_FBALL_22_21_11->name+69)='b';
*(FCNN_2L_1out_FBALL_22_21_11->name+70)='a';
*(FCNN_2L_1out_FBALL_22_21_11->name+71)='c';
*(FCNN_2L_1out_FBALL_22_21_11->name+72)='k';
*(FCNN_2L_1out_FBALL_22_21_11->name+73)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+74)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+75)='>';
*(FCNN_2L_1out_FBALL_22_21_11->name+76)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+77)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+78)='2';
*(FCNN_2L_1out_FBALL_22_21_11->name+79)='>';
*(FCNN_2L_1out_FBALL_22_21_11->name+80)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+81)='_';
*(FCNN_2L_1out_FBALL_22_21_11->name+82)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+83)='>';
*(FCNN_2L_1out_FBALL_22_21_11->name+84)='1';
*(FCNN_2L_1out_FBALL_22_21_11->name+85)=')';
*(FCNN_2L_1out_FBALL_22_21_11->name+86)=' ';
FCNN_2L_1out_FBALL_22_21_11->number_of_Levels=2;
FCNN_2L_1out_FBALL_22_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedbacks */
FCNN_2L_1out_FBALL_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FBALL_22_21_11->number_of_Levels);
*(FCNN_2L_1out_FBALL_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FBALL_22_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FBALL_22_21_11->recurrence=T;
FCNN_2L_1out_FBALL_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_1out_FBALL_22_21_11->source=MAI((long int)FCNN_2L_1out_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22_21_11->source+0)=2;
*(FCNN_2L_1out_FBALL_22_21_11->source+1)=2;
*(FCNN_2L_1out_FBALL_22_21_11->source+2)=1;
FCNN_2L_1out_FBALL_22_21_11->destination=MAI((long int)FCNN_2L_1out_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FBALL_22_21_11->destination+0)=2;
*(FCNN_2L_1out_FBALL_22_21_11->destination+1)=1;
*(FCNN_2L_1out_FBALL_22_21_11->destination+2)=1;
FCNN_2L_1out_FBALL_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FBALL_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21_11->create_neuron==0) exit_handling(60,1);
*(FCNN_2L_1out_FBALL_22_21_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_22_21_11;
FCNN_2L_1out_FBALL_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FBALL_22_21_11->prepare_input=0;
FCNN_2L_1out_FBALL_22_21_11->number_linear_output_functions=3;
FCNN_2L_1out_FBALL_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21_11->node_linear_output==0) exit_handling(60,2);
*(FCNN_2L_1out_FBALL_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FBALL_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FBALL_22_21_11->number_of_node_output_functions=4;
FCNN_2L_1out_FBALL_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21_11->node_output==0) exit_handling(60,3);
*(FCNN_2L_1out_FBALL_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FBALL_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FBALL_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FBALL_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FBALL_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21_11->node_output_derivation==0) exit_handling(60,4);
*(FCNN_2L_1out_FBALL_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FBALL_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FBALL_22_21_11->number_of_firing_functions=2;
FCNN_2L_1out_FBALL_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21_11->firing_neuron==0) exit_handling(60,5);
*(FCNN_2L_1out_FBALL_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FBALL_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FBALL_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FBALL_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FBALL_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FBALL_22_21_11->create_learning_algorithm==0) exit_handling(60,6);
*(FCNN_2L_1out_FBALL_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FBALL_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FBALL_22_21_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_11;
FCNN_2L_W_1out_FBALL_11=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_11->name=MAC((long int)106);
*(FCNN_2L_W_1out_FBALL_11->name+0)='F';
*(FCNN_2L_W_1out_FBALL_11->name+1)='C';
*(FCNN_2L_W_1out_FBALL_11->name+2)='N';
*(FCNN_2L_W_1out_FBALL_11->name+3)='N';
*(FCNN_2L_W_1out_FBALL_11->name+4)='_';
*(FCNN_2L_W_1out_FBALL_11->name+5)='2';
*(FCNN_2L_W_1out_FBALL_11->name+6)='L';
*(FCNN_2L_W_1out_FBALL_11->name+7)='_';
*(FCNN_2L_W_1out_FBALL_11->name+8)='W';
*(FCNN_2L_W_1out_FBALL_11->name+9)='_';
*(FCNN_2L_W_1out_FBALL_11->name+10)='1';
*(FCNN_2L_W_1out_FBALL_11->name+11)='o';
*(FCNN_2L_W_1out_FBALL_11->name+12)='u';
*(FCNN_2L_W_1out_FBALL_11->name+13)='t';
*(FCNN_2L_W_1out_FBALL_11->name+14)='_';
*(FCNN_2L_W_1out_FBALL_11->name+15)='F';
*(FCNN_2L_W_1out_FBALL_11->name+16)='B';
*(FCNN_2L_W_1out_FBALL_11->name+17)='A';
*(FCNN_2L_W_1out_FBALL_11->name+18)='L';
*(FCNN_2L_W_1out_FBALL_11->name+19)='L';
*(FCNN_2L_W_1out_FBALL_11->name+20)='_';
*(FCNN_2L_W_1out_FBALL_11->name+21)='1';
*(FCNN_2L_W_1out_FBALL_11->name+22)='1';
*(FCNN_2L_W_1out_FBALL_11->name+23)='(';
*(FCNN_2L_W_1out_FBALL_11->name+24)='F';
*(FCNN_2L_W_1out_FBALL_11->name+25)='u';
*(FCNN_2L_W_1out_FBALL_11->name+26)='l';
*(FCNN_2L_W_1out_FBALL_11->name+27)='l';
*(FCNN_2L_W_1out_FBALL_11->name+28)='y';
*(FCNN_2L_W_1out_FBALL_11->name+29)='_';
*(FCNN_2L_W_1out_FBALL_11->name+30)='C';
*(FCNN_2L_W_1out_FBALL_11->name+31)='o';
*(FCNN_2L_W_1out_FBALL_11->name+32)='n';
*(FCNN_2L_W_1out_FBALL_11->name+33)='n';
*(FCNN_2L_W_1out_FBALL_11->name+34)='e';
*(FCNN_2L_W_1out_FBALL_11->name+35)='c';
*(FCNN_2L_W_1out_FBALL_11->name+36)='t';
*(FCNN_2L_W_1out_FBALL_11->name+37)='e';
*(FCNN_2L_W_1out_FBALL_11->name+38)='d';
*(FCNN_2L_W_1out_FBALL_11->name+39)='_';
*(FCNN_2L_W_1out_FBALL_11->name+40)='N';
*(FCNN_2L_W_1out_FBALL_11->name+41)='N';
*(FCNN_2L_W_1out_FBALL_11->name+42)='_';
*(FCNN_2L_W_1out_FBALL_11->name+43)='2';
*(FCNN_2L_W_1out_FBALL_11->name+44)='_';
*(FCNN_2L_W_1out_FBALL_11->name+45)='L';
*(FCNN_2L_W_1out_FBALL_11->name+46)='a';
*(FCNN_2L_W_1out_FBALL_11->name+47)='y';
*(FCNN_2L_W_1out_FBALL_11->name+48)='e';
*(FCNN_2L_W_1out_FBALL_11->name+49)='r';
*(FCNN_2L_W_1out_FBALL_11->name+50)='s';
*(FCNN_2L_W_1out_FBALL_11->name+51)='_';
*(FCNN_2L_W_1out_FBALL_11->name+52)='r';
*(FCNN_2L_W_1out_FBALL_11->name+53)='e';
*(FCNN_2L_W_1out_FBALL_11->name+54)='c';
*(FCNN_2L_W_1out_FBALL_11->name+55)='e';
*(FCNN_2L_W_1out_FBALL_11->name+56)='i';
*(FCNN_2L_W_1out_FBALL_11->name+57)='v';
*(FCNN_2L_W_1out_FBALL_11->name+58)='i';
*(FCNN_2L_W_1out_FBALL_11->name+59)='n';
*(FCNN_2L_W_1out_FBALL_11->name+60)='g';
*(FCNN_2L_W_1out_FBALL_11->name+61)='_';
*(FCNN_2L_W_1out_FBALL_11->name+62)='i';
*(FCNN_2L_W_1out_FBALL_11->name+63)='n';
*(FCNN_2L_W_1out_FBALL_11->name+64)='p';
*(FCNN_2L_W_1out_FBALL_11->name+65)='u';
*(FCNN_2L_W_1out_FBALL_11->name+66)='t';
*(FCNN_2L_W_1out_FBALL_11->name+67)='_';
*(FCNN_2L_W_1out_FBALL_11->name+68)='t';
*(FCNN_2L_W_1out_FBALL_11->name+69)='h';
*(FCNN_2L_W_1out_FBALL_11->name+70)='r';
*(FCNN_2L_W_1out_FBALL_11->name+71)='o';
*(FCNN_2L_W_1out_FBALL_11->name+72)='u';
*(FCNN_2L_W_1out_FBALL_11->name+73)='g';
*(FCNN_2L_W_1out_FBALL_11->name+74)='h';
*(FCNN_2L_W_1out_FBALL_11->name+75)='_';
*(FCNN_2L_W_1out_FBALL_11->name+76)='W';
*(FCNN_2L_W_1out_FBALL_11->name+77)='i';
*(FCNN_2L_W_1out_FBALL_11->name+78)='n';
*(FCNN_2L_W_1out_FBALL_11->name+79)='d';
*(FCNN_2L_W_1out_FBALL_11->name+80)='o';
*(FCNN_2L_W_1out_FBALL_11->name+81)='w';
*(FCNN_2L_W_1out_FBALL_11->name+82)='_';
*(FCNN_2L_W_1out_FBALL_11->name+83)='1';
*(FCNN_2L_W_1out_FBALL_11->name+84)='_';
*(FCNN_2L_W_1out_FBALL_11->name+85)='o';
*(FCNN_2L_W_1out_FBALL_11->name+86)='u';
*(FCNN_2L_W_1out_FBALL_11->name+87)='t';
*(FCNN_2L_W_1out_FBALL_11->name+88)='p';
*(FCNN_2L_W_1out_FBALL_11->name+89)='u';
*(FCNN_2L_W_1out_FBALL_11->name+90)='t';
*(FCNN_2L_W_1out_FBALL_11->name+91)='_';
*(FCNN_2L_W_1out_FBALL_11->name+92)='f';
*(FCNN_2L_W_1out_FBALL_11->name+93)='e';
*(FCNN_2L_W_1out_FBALL_11->name+94)='e';
*(FCNN_2L_W_1out_FBALL_11->name+95)='d';
*(FCNN_2L_W_1out_FBALL_11->name+96)='b';
*(FCNN_2L_W_1out_FBALL_11->name+97)='a';
*(FCNN_2L_W_1out_FBALL_11->name+98)='c';
*(FCNN_2L_W_1out_FBALL_11->name+99)='k';
*(FCNN_2L_W_1out_FBALL_11->name+100)='_';
*(FCNN_2L_W_1out_FBALL_11->name+101)='1';
*(FCNN_2L_W_1out_FBALL_11->name+102)='>';
*(FCNN_2L_W_1out_FBALL_11->name+103)='1';
*(FCNN_2L_W_1out_FBALL_11->name+104)=')';
*(FCNN_2L_W_1out_FBALL_11->name+105)=' ';
FCNN_2L_W_1out_FBALL_11->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_11->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FBALL_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_11->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_11->recurrence=T;
FCNN_2L_W_1out_FBALL_11->number_of_recurrent_connected_layers=1;
FCNN_2L_W_1out_FBALL_11->source=MAI((long int)FCNN_2L_W_1out_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_11->source+0)=1;
FCNN_2L_W_1out_FBALL_11->destination=MAI((long int)FCNN_2L_W_1out_FBALL_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_11->destination+0)=1;
FCNN_2L_W_1out_FBALL_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_11->create_neuron==0) exit_handling(61,1);
*(FCNN_2L_W_1out_FBALL_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_11;
FCNN_2L_W_1out_FBALL_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_11->node_linear_output==0) exit_handling(61,2);
*(FCNN_2L_W_1out_FBALL_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_11->node_output==0) exit_handling(61,3);
*(FCNN_2L_W_1out_FBALL_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_11->node_output_derivation==0) exit_handling(61,4);
*(FCNN_2L_W_1out_FBALL_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_11->firing_neuron==0) exit_handling(61,5);
*(FCNN_2L_W_1out_FBALL_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FBALL_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FBALL_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_11->create_learning_algorithm==0) exit_handling(61,6);
*(FCNN_2L_W_1out_FBALL_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_22 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_22;
FCNN_2L_W_1out_FBALL_22=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_22->name=MAC((long int)106);
*(FCNN_2L_W_1out_FBALL_22->name+0)='F';
*(FCNN_2L_W_1out_FBALL_22->name+1)='C';
*(FCNN_2L_W_1out_FBALL_22->name+2)='N';
*(FCNN_2L_W_1out_FBALL_22->name+3)='N';
*(FCNN_2L_W_1out_FBALL_22->name+4)='_';
*(FCNN_2L_W_1out_FBALL_22->name+5)='2';
*(FCNN_2L_W_1out_FBALL_22->name+6)='L';
*(FCNN_2L_W_1out_FBALL_22->name+7)='_';
*(FCNN_2L_W_1out_FBALL_22->name+8)='W';
*(FCNN_2L_W_1out_FBALL_22->name+9)='_';
*(FCNN_2L_W_1out_FBALL_22->name+10)='1';
*(FCNN_2L_W_1out_FBALL_22->name+11)='o';
*(FCNN_2L_W_1out_FBALL_22->name+12)='u';
*(FCNN_2L_W_1out_FBALL_22->name+13)='t';
*(FCNN_2L_W_1out_FBALL_22->name+14)='_';
*(FCNN_2L_W_1out_FBALL_22->name+15)='F';
*(FCNN_2L_W_1out_FBALL_22->name+16)='B';
*(FCNN_2L_W_1out_FBALL_22->name+17)='A';
*(FCNN_2L_W_1out_FBALL_22->name+18)='L';
*(FCNN_2L_W_1out_FBALL_22->name+19)='L';
*(FCNN_2L_W_1out_FBALL_22->name+20)='_';
*(FCNN_2L_W_1out_FBALL_22->name+21)='2';
*(FCNN_2L_W_1out_FBALL_22->name+22)='2';
*(FCNN_2L_W_1out_FBALL_22->name+23)='(';
*(FCNN_2L_W_1out_FBALL_22->name+24)='F';
*(FCNN_2L_W_1out_FBALL_22->name+25)='u';
*(FCNN_2L_W_1out_FBALL_22->name+26)='l';
*(FCNN_2L_W_1out_FBALL_22->name+27)='l';
*(FCNN_2L_W_1out_FBALL_22->name+28)='y';
*(FCNN_2L_W_1out_FBALL_22->name+29)='_';
*(FCNN_2L_W_1out_FBALL_22->name+30)='C';
*(FCNN_2L_W_1out_FBALL_22->name+31)='o';
*(FCNN_2L_W_1out_FBALL_22->name+32)='n';
*(FCNN_2L_W_1out_FBALL_22->name+33)='n';
*(FCNN_2L_W_1out_FBALL_22->name+34)='e';
*(FCNN_2L_W_1out_FBALL_22->name+35)='c';
*(FCNN_2L_W_1out_FBALL_22->name+36)='t';
*(FCNN_2L_W_1out_FBALL_22->name+37)='e';
*(FCNN_2L_W_1out_FBALL_22->name+38)='d';
*(FCNN_2L_W_1out_FBALL_22->name+39)='_';
*(FCNN_2L_W_1out_FBALL_22->name+40)='N';
*(FCNN_2L_W_1out_FBALL_22->name+41)='N';
*(FCNN_2L_W_1out_FBALL_22->name+42)='_';
*(FCNN_2L_W_1out_FBALL_22->name+43)='2';
*(FCNN_2L_W_1out_FBALL_22->name+44)='_';
*(FCNN_2L_W_1out_FBALL_22->name+45)='L';
*(FCNN_2L_W_1out_FBALL_22->name+46)='a';
*(FCNN_2L_W_1out_FBALL_22->name+47)='y';
*(FCNN_2L_W_1out_FBALL_22->name+48)='e';
*(FCNN_2L_W_1out_FBALL_22->name+49)='r';
*(FCNN_2L_W_1out_FBALL_22->name+50)='s';
*(FCNN_2L_W_1out_FBALL_22->name+51)='_';
*(FCNN_2L_W_1out_FBALL_22->name+52)='r';
*(FCNN_2L_W_1out_FBALL_22->name+53)='e';
*(FCNN_2L_W_1out_FBALL_22->name+54)='c';
*(FCNN_2L_W_1out_FBALL_22->name+55)='e';
*(FCNN_2L_W_1out_FBALL_22->name+56)='i';
*(FCNN_2L_W_1out_FBALL_22->name+57)='v';
*(FCNN_2L_W_1out_FBALL_22->name+58)='i';
*(FCNN_2L_W_1out_FBALL_22->name+59)='n';
*(FCNN_2L_W_1out_FBALL_22->name+60)='g';
*(FCNN_2L_W_1out_FBALL_22->name+61)='_';
*(FCNN_2L_W_1out_FBALL_22->name+62)='i';
*(FCNN_2L_W_1out_FBALL_22->name+63)='n';
*(FCNN_2L_W_1out_FBALL_22->name+64)='p';
*(FCNN_2L_W_1out_FBALL_22->name+65)='u';
*(FCNN_2L_W_1out_FBALL_22->name+66)='t';
*(FCNN_2L_W_1out_FBALL_22->name+67)='_';
*(FCNN_2L_W_1out_FBALL_22->name+68)='t';
*(FCNN_2L_W_1out_FBALL_22->name+69)='h';
*(FCNN_2L_W_1out_FBALL_22->name+70)='r';
*(FCNN_2L_W_1out_FBALL_22->name+71)='o';
*(FCNN_2L_W_1out_FBALL_22->name+72)='u';
*(FCNN_2L_W_1out_FBALL_22->name+73)='g';
*(FCNN_2L_W_1out_FBALL_22->name+74)='h';
*(FCNN_2L_W_1out_FBALL_22->name+75)='_';
*(FCNN_2L_W_1out_FBALL_22->name+76)='W';
*(FCNN_2L_W_1out_FBALL_22->name+77)='i';
*(FCNN_2L_W_1out_FBALL_22->name+78)='n';
*(FCNN_2L_W_1out_FBALL_22->name+79)='d';
*(FCNN_2L_W_1out_FBALL_22->name+80)='o';
*(FCNN_2L_W_1out_FBALL_22->name+81)='w';
*(FCNN_2L_W_1out_FBALL_22->name+82)='_';
*(FCNN_2L_W_1out_FBALL_22->name+83)='1';
*(FCNN_2L_W_1out_FBALL_22->name+84)='_';
*(FCNN_2L_W_1out_FBALL_22->name+85)='o';
*(FCNN_2L_W_1out_FBALL_22->name+86)='u';
*(FCNN_2L_W_1out_FBALL_22->name+87)='t';
*(FCNN_2L_W_1out_FBALL_22->name+88)='p';
*(FCNN_2L_W_1out_FBALL_22->name+89)='u';
*(FCNN_2L_W_1out_FBALL_22->name+90)='t';
*(FCNN_2L_W_1out_FBALL_22->name+91)='_';
*(FCNN_2L_W_1out_FBALL_22->name+92)='f';
*(FCNN_2L_W_1out_FBALL_22->name+93)='e';
*(FCNN_2L_W_1out_FBALL_22->name+94)='e';
*(FCNN_2L_W_1out_FBALL_22->name+95)='d';
*(FCNN_2L_W_1out_FBALL_22->name+96)='b';
*(FCNN_2L_W_1out_FBALL_22->name+97)='a';
*(FCNN_2L_W_1out_FBALL_22->name+98)='c';
*(FCNN_2L_W_1out_FBALL_22->name+99)='k';
*(FCNN_2L_W_1out_FBALL_22->name+100)='_';
*(FCNN_2L_W_1out_FBALL_22->name+101)='2';
*(FCNN_2L_W_1out_FBALL_22->name+102)='>';
*(FCNN_2L_W_1out_FBALL_22->name+103)='2';
*(FCNN_2L_W_1out_FBALL_22->name+104)=')';
*(FCNN_2L_W_1out_FBALL_22->name+105)=' ';
FCNN_2L_W_1out_FBALL_22->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_22->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_22->prepare_input()) */
FCNN_2L_W_1out_FBALL_22->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_22->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_22->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_22->recurrence=T;
FCNN_2L_W_1out_FBALL_22->number_of_recurrent_connected_layers=1;
FCNN_2L_W_1out_FBALL_22->source=MAI((long int)FCNN_2L_W_1out_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22->source+0)=2;
FCNN_2L_W_1out_FBALL_22->destination=MAI((long int)FCNN_2L_W_1out_FBALL_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22->destination+0)=2;
FCNN_2L_W_1out_FBALL_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22->create_neuron==0) exit_handling(62,1);
*(FCNN_2L_W_1out_FBALL_22->create_neuron+0)=create_FCNN_2L_1out_FBALL_22;
FCNN_2L_W_1out_FBALL_22->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_22->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_22->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22->node_linear_output==0) exit_handling(62,2);
*(FCNN_2L_W_1out_FBALL_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_22->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_22->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22->node_output==0) exit_handling(62,3);
*(FCNN_2L_W_1out_FBALL_22->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22->node_output_derivation==0) exit_handling(62,4);
*(FCNN_2L_W_1out_FBALL_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_22->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22->firing_neuron==0) exit_handling(62,5);
*(FCNN_2L_W_1out_FBALL_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FBALL_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FBALL_22->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22->create_learning_algorithm==0) exit_handling(62,6);
*(FCNN_2L_W_1out_FBALL_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_22);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto the 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_21;
FCNN_2L_W_1out_FBALL_21=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_21->name=MAC((long int)106);
*(FCNN_2L_W_1out_FBALL_21->name+0)='F';
*(FCNN_2L_W_1out_FBALL_21->name+1)='C';
*(FCNN_2L_W_1out_FBALL_21->name+2)='N';
*(FCNN_2L_W_1out_FBALL_21->name+3)='N';
*(FCNN_2L_W_1out_FBALL_21->name+4)='_';
*(FCNN_2L_W_1out_FBALL_21->name+5)='2';
*(FCNN_2L_W_1out_FBALL_21->name+6)='L';
*(FCNN_2L_W_1out_FBALL_21->name+7)='_';
*(FCNN_2L_W_1out_FBALL_21->name+8)='W';
*(FCNN_2L_W_1out_FBALL_21->name+9)='_';
*(FCNN_2L_W_1out_FBALL_21->name+10)='1';
*(FCNN_2L_W_1out_FBALL_21->name+11)='o';
*(FCNN_2L_W_1out_FBALL_21->name+12)='u';
*(FCNN_2L_W_1out_FBALL_21->name+13)='t';
*(FCNN_2L_W_1out_FBALL_21->name+14)='_';
*(FCNN_2L_W_1out_FBALL_21->name+15)='F';
*(FCNN_2L_W_1out_FBALL_21->name+16)='B';
*(FCNN_2L_W_1out_FBALL_21->name+17)='A';
*(FCNN_2L_W_1out_FBALL_21->name+18)='L';
*(FCNN_2L_W_1out_FBALL_21->name+19)='L';
*(FCNN_2L_W_1out_FBALL_21->name+20)='_';
*(FCNN_2L_W_1out_FBALL_21->name+21)='2';
*(FCNN_2L_W_1out_FBALL_21->name+22)='1';
*(FCNN_2L_W_1out_FBALL_21->name+23)='(';
*(FCNN_2L_W_1out_FBALL_21->name+24)='F';
*(FCNN_2L_W_1out_FBALL_21->name+25)='u';
*(FCNN_2L_W_1out_FBALL_21->name+26)='l';
*(FCNN_2L_W_1out_FBALL_21->name+27)='l';
*(FCNN_2L_W_1out_FBALL_21->name+28)='y';
*(FCNN_2L_W_1out_FBALL_21->name+29)='_';
*(FCNN_2L_W_1out_FBALL_21->name+30)='C';
*(FCNN_2L_W_1out_FBALL_21->name+31)='o';
*(FCNN_2L_W_1out_FBALL_21->name+32)='n';
*(FCNN_2L_W_1out_FBALL_21->name+33)='n';
*(FCNN_2L_W_1out_FBALL_21->name+34)='e';
*(FCNN_2L_W_1out_FBALL_21->name+35)='c';
*(FCNN_2L_W_1out_FBALL_21->name+36)='t';
*(FCNN_2L_W_1out_FBALL_21->name+37)='e';
*(FCNN_2L_W_1out_FBALL_21->name+38)='d';
*(FCNN_2L_W_1out_FBALL_21->name+39)='_';
*(FCNN_2L_W_1out_FBALL_21->name+40)='N';
*(FCNN_2L_W_1out_FBALL_21->name+41)='N';
*(FCNN_2L_W_1out_FBALL_21->name+42)='_';
*(FCNN_2L_W_1out_FBALL_21->name+43)='2';
*(FCNN_2L_W_1out_FBALL_21->name+44)='_';
*(FCNN_2L_W_1out_FBALL_21->name+45)='L';
*(FCNN_2L_W_1out_FBALL_21->name+46)='a';
*(FCNN_2L_W_1out_FBALL_21->name+47)='y';
*(FCNN_2L_W_1out_FBALL_21->name+48)='e';
*(FCNN_2L_W_1out_FBALL_21->name+49)='r';
*(FCNN_2L_W_1out_FBALL_21->name+50)='s';
*(FCNN_2L_W_1out_FBALL_21->name+51)='_';
*(FCNN_2L_W_1out_FBALL_21->name+52)='r';
*(FCNN_2L_W_1out_FBALL_21->name+53)='e';
*(FCNN_2L_W_1out_FBALL_21->name+54)='c';
*(FCNN_2L_W_1out_FBALL_21->name+55)='e';
*(FCNN_2L_W_1out_FBALL_21->name+56)='i';
*(FCNN_2L_W_1out_FBALL_21->name+57)='v';
*(FCNN_2L_W_1out_FBALL_21->name+58)='i';
*(FCNN_2L_W_1out_FBALL_21->name+59)='n';
*(FCNN_2L_W_1out_FBALL_21->name+60)='g';
*(FCNN_2L_W_1out_FBALL_21->name+61)='_';
*(FCNN_2L_W_1out_FBALL_21->name+62)='i';
*(FCNN_2L_W_1out_FBALL_21->name+63)='n';
*(FCNN_2L_W_1out_FBALL_21->name+64)='p';
*(FCNN_2L_W_1out_FBALL_21->name+65)='u';
*(FCNN_2L_W_1out_FBALL_21->name+66)='t';
*(FCNN_2L_W_1out_FBALL_21->name+67)='_';
*(FCNN_2L_W_1out_FBALL_21->name+68)='t';
*(FCNN_2L_W_1out_FBALL_21->name+69)='h';
*(FCNN_2L_W_1out_FBALL_21->name+70)='r';
*(FCNN_2L_W_1out_FBALL_21->name+71)='o';
*(FCNN_2L_W_1out_FBALL_21->name+72)='u';
*(FCNN_2L_W_1out_FBALL_21->name+73)='g';
*(FCNN_2L_W_1out_FBALL_21->name+74)='h';
*(FCNN_2L_W_1out_FBALL_21->name+75)='_';
*(FCNN_2L_W_1out_FBALL_21->name+76)='W';
*(FCNN_2L_W_1out_FBALL_21->name+77)='i';
*(FCNN_2L_W_1out_FBALL_21->name+78)='n';
*(FCNN_2L_W_1out_FBALL_21->name+79)='d';
*(FCNN_2L_W_1out_FBALL_21->name+80)='o';
*(FCNN_2L_W_1out_FBALL_21->name+81)='w';
*(FCNN_2L_W_1out_FBALL_21->name+82)='_';
*(FCNN_2L_W_1out_FBALL_21->name+83)='1';
*(FCNN_2L_W_1out_FBALL_21->name+84)='_';
*(FCNN_2L_W_1out_FBALL_21->name+85)='o';
*(FCNN_2L_W_1out_FBALL_21->name+86)='u';
*(FCNN_2L_W_1out_FBALL_21->name+87)='t';
*(FCNN_2L_W_1out_FBALL_21->name+88)='p';
*(FCNN_2L_W_1out_FBALL_21->name+89)='u';
*(FCNN_2L_W_1out_FBALL_21->name+90)='t';
*(FCNN_2L_W_1out_FBALL_21->name+91)='_';
*(FCNN_2L_W_1out_FBALL_21->name+92)='f';
*(FCNN_2L_W_1out_FBALL_21->name+93)='e';
*(FCNN_2L_W_1out_FBALL_21->name+94)='e';
*(FCNN_2L_W_1out_FBALL_21->name+95)='d';
*(FCNN_2L_W_1out_FBALL_21->name+96)='b';
*(FCNN_2L_W_1out_FBALL_21->name+97)='a';
*(FCNN_2L_W_1out_FBALL_21->name+98)='c';
*(FCNN_2L_W_1out_FBALL_21->name+99)='k';
*(FCNN_2L_W_1out_FBALL_21->name+100)='_';
*(FCNN_2L_W_1out_FBALL_21->name+101)='2';
*(FCNN_2L_W_1out_FBALL_21->name+102)='>';
*(FCNN_2L_W_1out_FBALL_21->name+103)='1';
*(FCNN_2L_W_1out_FBALL_21->name+104)=')';
*(FCNN_2L_W_1out_FBALL_21->name+105)=' ';
FCNN_2L_W_1out_FBALL_21->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_21->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FBALL_21->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_21->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_21->recurrence=T;
FCNN_2L_W_1out_FBALL_21->number_of_recurrent_connected_layers=1;
FCNN_2L_W_1out_FBALL_21->source=MAI((long int)FCNN_2L_W_1out_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_21->source+0)=2;
FCNN_2L_W_1out_FBALL_21->destination=MAI((long int)FCNN_2L_W_1out_FBALL_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_21->destination+0)=1;
FCNN_2L_W_1out_FBALL_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21->create_neuron==0) exit_handling(63,1);
*(FCNN_2L_W_1out_FBALL_21->create_neuron+0)=create_FCNN_2L_1out_FBALL_21;
FCNN_2L_W_1out_FBALL_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_21->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21->node_linear_output==0) exit_handling(63,2);
*(FCNN_2L_W_1out_FBALL_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_21->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21->node_output==0) exit_handling(63,3);
*(FCNN_2L_W_1out_FBALL_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21->node_output_derivation==0) exit_handling(63,4);
*(FCNN_2L_W_1out_FBALL_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_21->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21->firing_neuron==0) exit_handling(63,5);
*(FCNN_2L_W_1out_FBALL_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_W_1out_FBALL_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_W_1out_FBALL_21->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21->create_learning_algorithm==0) exit_handling(63,6);
*(FCNN_2L_W_1out_FBALL_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_21);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_22_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_22_11;
FCNN_2L_W_1out_FBALL_22_11=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_22_11->name=MAC((long int)113);
*(FCNN_2L_W_1out_FBALL_22_11->name+0)='F';
*(FCNN_2L_W_1out_FBALL_22_11->name+1)='C';
*(FCNN_2L_W_1out_FBALL_22_11->name+2)='N';
*(FCNN_2L_W_1out_FBALL_22_11->name+3)='N';
*(FCNN_2L_W_1out_FBALL_22_11->name+4)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+5)='2';
*(FCNN_2L_W_1out_FBALL_22_11->name+6)='L';
*(FCNN_2L_W_1out_FBALL_22_11->name+7)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+8)='W';
*(FCNN_2L_W_1out_FBALL_22_11->name+9)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+10)='1';
*(FCNN_2L_W_1out_FBALL_22_11->name+11)='o';
*(FCNN_2L_W_1out_FBALL_22_11->name+12)='u';
*(FCNN_2L_W_1out_FBALL_22_11->name+13)='t';
*(FCNN_2L_W_1out_FBALL_22_11->name+14)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+15)='F';
*(FCNN_2L_W_1out_FBALL_22_11->name+16)='B';
*(FCNN_2L_W_1out_FBALL_22_11->name+17)='A';
*(FCNN_2L_W_1out_FBALL_22_11->name+18)='L';
*(FCNN_2L_W_1out_FBALL_22_11->name+19)='L';
*(FCNN_2L_W_1out_FBALL_22_11->name+20)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+21)='2';
*(FCNN_2L_W_1out_FBALL_22_11->name+22)='2';
*(FCNN_2L_W_1out_FBALL_22_11->name+23)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+24)='1';
*(FCNN_2L_W_1out_FBALL_22_11->name+25)='1';
*(FCNN_2L_W_1out_FBALL_22_11->name+26)='(';
*(FCNN_2L_W_1out_FBALL_22_11->name+27)='F';
*(FCNN_2L_W_1out_FBALL_22_11->name+28)='u';
*(FCNN_2L_W_1out_FBALL_22_11->name+29)='l';
*(FCNN_2L_W_1out_FBALL_22_11->name+30)='l';
*(FCNN_2L_W_1out_FBALL_22_11->name+31)='y';
*(FCNN_2L_W_1out_FBALL_22_11->name+32)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+33)='C';
*(FCNN_2L_W_1out_FBALL_22_11->name+34)='o';
*(FCNN_2L_W_1out_FBALL_22_11->name+35)='n';
*(FCNN_2L_W_1out_FBALL_22_11->name+36)='n';
*(FCNN_2L_W_1out_FBALL_22_11->name+37)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+38)='c';
*(FCNN_2L_W_1out_FBALL_22_11->name+39)='t';
*(FCNN_2L_W_1out_FBALL_22_11->name+40)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+41)='d';
*(FCNN_2L_W_1out_FBALL_22_11->name+42)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+43)='N';
*(FCNN_2L_W_1out_FBALL_22_11->name+44)='N';
*(FCNN_2L_W_1out_FBALL_22_11->name+45)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+46)='2';
*(FCNN_2L_W_1out_FBALL_22_11->name+47)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+48)='L';
*(FCNN_2L_W_1out_FBALL_22_11->name+49)='a';
*(FCNN_2L_W_1out_FBALL_22_11->name+50)='y';
*(FCNN_2L_W_1out_FBALL_22_11->name+51)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+52)='r';
*(FCNN_2L_W_1out_FBALL_22_11->name+53)='s';
*(FCNN_2L_W_1out_FBALL_22_11->name+54)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+55)='r';
*(FCNN_2L_W_1out_FBALL_22_11->name+56)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+57)='c';
*(FCNN_2L_W_1out_FBALL_22_11->name+58)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+59)='i';
*(FCNN_2L_W_1out_FBALL_22_11->name+60)='v';
*(FCNN_2L_W_1out_FBALL_22_11->name+61)='i';
*(FCNN_2L_W_1out_FBALL_22_11->name+62)='n';
*(FCNN_2L_W_1out_FBALL_22_11->name+63)='g';
*(FCNN_2L_W_1out_FBALL_22_11->name+64)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+65)='i';
*(FCNN_2L_W_1out_FBALL_22_11->name+66)='n';
*(FCNN_2L_W_1out_FBALL_22_11->name+67)='p';
*(FCNN_2L_W_1out_FBALL_22_11->name+68)='u';
*(FCNN_2L_W_1out_FBALL_22_11->name+69)='t';
*(FCNN_2L_W_1out_FBALL_22_11->name+70)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+71)='t';
*(FCNN_2L_W_1out_FBALL_22_11->name+72)='h';
*(FCNN_2L_W_1out_FBALL_22_11->name+73)='r';
*(FCNN_2L_W_1out_FBALL_22_11->name+74)='o';
*(FCNN_2L_W_1out_FBALL_22_11->name+75)='u';
*(FCNN_2L_W_1out_FBALL_22_11->name+76)='g';
*(FCNN_2L_W_1out_FBALL_22_11->name+77)='h';
*(FCNN_2L_W_1out_FBALL_22_11->name+78)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+79)='W';
*(FCNN_2L_W_1out_FBALL_22_11->name+80)='i';
*(FCNN_2L_W_1out_FBALL_22_11->name+81)='n';
*(FCNN_2L_W_1out_FBALL_22_11->name+82)='d';
*(FCNN_2L_W_1out_FBALL_22_11->name+83)='o';
*(FCNN_2L_W_1out_FBALL_22_11->name+84)='w';
*(FCNN_2L_W_1out_FBALL_22_11->name+85)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+86)='1';
*(FCNN_2L_W_1out_FBALL_22_11->name+87)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+88)='o';
*(FCNN_2L_W_1out_FBALL_22_11->name+89)='u';
*(FCNN_2L_W_1out_FBALL_22_11->name+90)='t';
*(FCNN_2L_W_1out_FBALL_22_11->name+91)='p';
*(FCNN_2L_W_1out_FBALL_22_11->name+92)='u';
*(FCNN_2L_W_1out_FBALL_22_11->name+93)='t';
*(FCNN_2L_W_1out_FBALL_22_11->name+94)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+95)='f';
*(FCNN_2L_W_1out_FBALL_22_11->name+96)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+97)='e';
*(FCNN_2L_W_1out_FBALL_22_11->name+98)='d';
*(FCNN_2L_W_1out_FBALL_22_11->name+99)='b';
*(FCNN_2L_W_1out_FBALL_22_11->name+100)='a';
*(FCNN_2L_W_1out_FBALL_22_11->name+101)='c';
*(FCNN_2L_W_1out_FBALL_22_11->name+102)='k';
*(FCNN_2L_W_1out_FBALL_22_11->name+103)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+104)='2';
*(FCNN_2L_W_1out_FBALL_22_11->name+105)='>';
*(FCNN_2L_W_1out_FBALL_22_11->name+106)='2';
*(FCNN_2L_W_1out_FBALL_22_11->name+107)='_';
*(FCNN_2L_W_1out_FBALL_22_11->name+108)='1';
*(FCNN_2L_W_1out_FBALL_22_11->name+109)='>';
*(FCNN_2L_W_1out_FBALL_22_11->name+110)='1';
*(FCNN_2L_W_1out_FBALL_22_11->name+111)=')';
*(FCNN_2L_W_1out_FBALL_22_11->name+112)=' ';
FCNN_2L_W_1out_FBALL_22_11->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_22_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_22_11->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FBALL_22_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_22_11->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_22_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_22_11->recurrence=T;
FCNN_2L_W_1out_FBALL_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_1out_FBALL_22_11->source=MAI((long int)FCNN_2L_W_1out_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22_11->source+0)=2;
*(FCNN_2L_W_1out_FBALL_22_11->source+1)=1;
FCNN_2L_W_1out_FBALL_22_11->destination=MAI((long int)FCNN_2L_W_1out_FBALL_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22_11->destination+0)=2;
*(FCNN_2L_W_1out_FBALL_22_11->destination+1)=1;
FCNN_2L_W_1out_FBALL_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_11->create_neuron==0) exit_handling(64,1);
*(FCNN_2L_W_1out_FBALL_22_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_22_11;
FCNN_2L_W_1out_FBALL_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_22_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_22_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_11->node_linear_output==0) exit_handling(64,2);
*(FCNN_2L_W_1out_FBALL_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_22_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_11->node_output==0) exit_handling(64,3);
*(FCNN_2L_W_1out_FBALL_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_11->node_output_derivation==0) exit_handling(64,4);
*(FCNN_2L_W_1out_FBALL_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_22_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_11->firing_neuron==0) exit_handling(64,5);
*(FCNN_2L_W_1out_FBALL_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FBALL_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FBALL_22_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_11->create_learning_algorithm==0) exit_handling(64,6);
*(FCNN_2L_W_1out_FBALL_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_22_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_21_11;
FCNN_2L_W_1out_FBALL_21_11=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_21_11->name=MAC((long int)113);
*(FCNN_2L_W_1out_FBALL_21_11->name+0)='F';
*(FCNN_2L_W_1out_FBALL_21_11->name+1)='C';
*(FCNN_2L_W_1out_FBALL_21_11->name+2)='N';
*(FCNN_2L_W_1out_FBALL_21_11->name+3)='N';
*(FCNN_2L_W_1out_FBALL_21_11->name+4)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+5)='2';
*(FCNN_2L_W_1out_FBALL_21_11->name+6)='L';
*(FCNN_2L_W_1out_FBALL_21_11->name+7)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+8)='W';
*(FCNN_2L_W_1out_FBALL_21_11->name+9)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+10)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+11)='o';
*(FCNN_2L_W_1out_FBALL_21_11->name+12)='u';
*(FCNN_2L_W_1out_FBALL_21_11->name+13)='t';
*(FCNN_2L_W_1out_FBALL_21_11->name+14)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+15)='F';
*(FCNN_2L_W_1out_FBALL_21_11->name+16)='B';
*(FCNN_2L_W_1out_FBALL_21_11->name+17)='A';
*(FCNN_2L_W_1out_FBALL_21_11->name+18)='L';
*(FCNN_2L_W_1out_FBALL_21_11->name+19)='L';
*(FCNN_2L_W_1out_FBALL_21_11->name+20)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+21)='2';
*(FCNN_2L_W_1out_FBALL_21_11->name+22)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+23)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+24)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+25)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+26)='(';
*(FCNN_2L_W_1out_FBALL_21_11->name+27)='F';
*(FCNN_2L_W_1out_FBALL_21_11->name+28)='u';
*(FCNN_2L_W_1out_FBALL_21_11->name+29)='l';
*(FCNN_2L_W_1out_FBALL_21_11->name+30)='l';
*(FCNN_2L_W_1out_FBALL_21_11->name+31)='y';
*(FCNN_2L_W_1out_FBALL_21_11->name+32)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+33)='C';
*(FCNN_2L_W_1out_FBALL_21_11->name+34)='o';
*(FCNN_2L_W_1out_FBALL_21_11->name+35)='n';
*(FCNN_2L_W_1out_FBALL_21_11->name+36)='n';
*(FCNN_2L_W_1out_FBALL_21_11->name+37)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+38)='c';
*(FCNN_2L_W_1out_FBALL_21_11->name+39)='t';
*(FCNN_2L_W_1out_FBALL_21_11->name+40)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+41)='d';
*(FCNN_2L_W_1out_FBALL_21_11->name+42)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+43)='N';
*(FCNN_2L_W_1out_FBALL_21_11->name+44)='N';
*(FCNN_2L_W_1out_FBALL_21_11->name+45)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+46)='2';
*(FCNN_2L_W_1out_FBALL_21_11->name+47)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+48)='L';
*(FCNN_2L_W_1out_FBALL_21_11->name+49)='a';
*(FCNN_2L_W_1out_FBALL_21_11->name+50)='y';
*(FCNN_2L_W_1out_FBALL_21_11->name+51)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+52)='r';
*(FCNN_2L_W_1out_FBALL_21_11->name+53)='s';
*(FCNN_2L_W_1out_FBALL_21_11->name+54)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+55)='r';
*(FCNN_2L_W_1out_FBALL_21_11->name+56)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+57)='c';
*(FCNN_2L_W_1out_FBALL_21_11->name+58)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+59)='i';
*(FCNN_2L_W_1out_FBALL_21_11->name+60)='v';
*(FCNN_2L_W_1out_FBALL_21_11->name+61)='i';
*(FCNN_2L_W_1out_FBALL_21_11->name+62)='n';
*(FCNN_2L_W_1out_FBALL_21_11->name+63)='g';
*(FCNN_2L_W_1out_FBALL_21_11->name+64)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+65)='i';
*(FCNN_2L_W_1out_FBALL_21_11->name+66)='n';
*(FCNN_2L_W_1out_FBALL_21_11->name+67)='p';
*(FCNN_2L_W_1out_FBALL_21_11->name+68)='u';
*(FCNN_2L_W_1out_FBALL_21_11->name+69)='t';
*(FCNN_2L_W_1out_FBALL_21_11->name+70)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+71)='t';
*(FCNN_2L_W_1out_FBALL_21_11->name+72)='h';
*(FCNN_2L_W_1out_FBALL_21_11->name+73)='r';
*(FCNN_2L_W_1out_FBALL_21_11->name+74)='o';
*(FCNN_2L_W_1out_FBALL_21_11->name+75)='u';
*(FCNN_2L_W_1out_FBALL_21_11->name+76)='g';
*(FCNN_2L_W_1out_FBALL_21_11->name+77)='h';
*(FCNN_2L_W_1out_FBALL_21_11->name+78)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+79)='W';
*(FCNN_2L_W_1out_FBALL_21_11->name+80)='i';
*(FCNN_2L_W_1out_FBALL_21_11->name+81)='n';
*(FCNN_2L_W_1out_FBALL_21_11->name+82)='d';
*(FCNN_2L_W_1out_FBALL_21_11->name+83)='o';
*(FCNN_2L_W_1out_FBALL_21_11->name+84)='w';
*(FCNN_2L_W_1out_FBALL_21_11->name+85)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+86)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+87)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+88)='o';
*(FCNN_2L_W_1out_FBALL_21_11->name+89)='u';
*(FCNN_2L_W_1out_FBALL_21_11->name+90)='t';
*(FCNN_2L_W_1out_FBALL_21_11->name+91)='p';
*(FCNN_2L_W_1out_FBALL_21_11->name+92)='u';
*(FCNN_2L_W_1out_FBALL_21_11->name+93)='t';
*(FCNN_2L_W_1out_FBALL_21_11->name+94)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+95)='f';
*(FCNN_2L_W_1out_FBALL_21_11->name+96)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+97)='e';
*(FCNN_2L_W_1out_FBALL_21_11->name+98)='d';
*(FCNN_2L_W_1out_FBALL_21_11->name+99)='b';
*(FCNN_2L_W_1out_FBALL_21_11->name+100)='a';
*(FCNN_2L_W_1out_FBALL_21_11->name+101)='c';
*(FCNN_2L_W_1out_FBALL_21_11->name+102)='k';
*(FCNN_2L_W_1out_FBALL_21_11->name+103)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+104)='2';
*(FCNN_2L_W_1out_FBALL_21_11->name+105)='>';
*(FCNN_2L_W_1out_FBALL_21_11->name+106)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+107)='_';
*(FCNN_2L_W_1out_FBALL_21_11->name+108)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+109)='>';
*(FCNN_2L_W_1out_FBALL_21_11->name+110)='1';
*(FCNN_2L_W_1out_FBALL_21_11->name+111)=')';
*(FCNN_2L_W_1out_FBALL_21_11->name+112)=' ';
FCNN_2L_W_1out_FBALL_21_11->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_21_11->prepare_input()) plus inputs from feedbacks */
FCNN_2L_W_1out_FBALL_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_21_11->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_21_11->recurrence=T;
FCNN_2L_W_1out_FBALL_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_1out_FBALL_21_11->source=MAI((long int)FCNN_2L_W_1out_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_21_11->source+0)=2;
*(FCNN_2L_W_1out_FBALL_21_11->source+1)=1;
FCNN_2L_W_1out_FBALL_21_11->destination=MAI((long int)FCNN_2L_W_1out_FBALL_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_21_11->destination+0)=1;
*(FCNN_2L_W_1out_FBALL_21_11->destination+1)=1;
FCNN_2L_W_1out_FBALL_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21_11->create_neuron==0) exit_handling(65,1);
*(FCNN_2L_W_1out_FBALL_21_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_21_11;
FCNN_2L_W_1out_FBALL_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_21_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21_11->node_linear_output==0) exit_handling(65,2);
*(FCNN_2L_W_1out_FBALL_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_21_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21_11->node_output==0) exit_handling(65,3);
*(FCNN_2L_W_1out_FBALL_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21_11->node_output_derivation==0) exit_handling(65,4);
*(FCNN_2L_W_1out_FBALL_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_21_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21_11->firing_neuron==0) exit_handling(65,5);
*(FCNN_2L_W_1out_FBALL_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FBALL_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FBALL_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_21_11->create_learning_algorithm==0) exit_handling(65,6);
*(FCNN_2L_W_1out_FBALL_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_21_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_22_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_22_21;
FCNN_2L_W_1out_FBALL_22_21=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_22_21->name=MAC((long int)113);
*(FCNN_2L_W_1out_FBALL_22_21->name+0)='F';
*(FCNN_2L_W_1out_FBALL_22_21->name+1)='C';
*(FCNN_2L_W_1out_FBALL_22_21->name+2)='N';
*(FCNN_2L_W_1out_FBALL_22_21->name+3)='N';
*(FCNN_2L_W_1out_FBALL_22_21->name+4)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+5)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+6)='L';
*(FCNN_2L_W_1out_FBALL_22_21->name+7)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+8)='W';
*(FCNN_2L_W_1out_FBALL_22_21->name+9)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+10)='1';
*(FCNN_2L_W_1out_FBALL_22_21->name+11)='o';
*(FCNN_2L_W_1out_FBALL_22_21->name+12)='u';
*(FCNN_2L_W_1out_FBALL_22_21->name+13)='t';
*(FCNN_2L_W_1out_FBALL_22_21->name+14)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+15)='F';
*(FCNN_2L_W_1out_FBALL_22_21->name+16)='B';
*(FCNN_2L_W_1out_FBALL_22_21->name+17)='A';
*(FCNN_2L_W_1out_FBALL_22_21->name+18)='L';
*(FCNN_2L_W_1out_FBALL_22_21->name+19)='L';
*(FCNN_2L_W_1out_FBALL_22_21->name+20)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+21)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+22)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+23)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+24)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+25)='1';
*(FCNN_2L_W_1out_FBALL_22_21->name+26)='(';
*(FCNN_2L_W_1out_FBALL_22_21->name+27)='F';
*(FCNN_2L_W_1out_FBALL_22_21->name+28)='u';
*(FCNN_2L_W_1out_FBALL_22_21->name+29)='l';
*(FCNN_2L_W_1out_FBALL_22_21->name+30)='l';
*(FCNN_2L_W_1out_FBALL_22_21->name+31)='y';
*(FCNN_2L_W_1out_FBALL_22_21->name+32)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+33)='C';
*(FCNN_2L_W_1out_FBALL_22_21->name+34)='o';
*(FCNN_2L_W_1out_FBALL_22_21->name+35)='n';
*(FCNN_2L_W_1out_FBALL_22_21->name+36)='n';
*(FCNN_2L_W_1out_FBALL_22_21->name+37)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+38)='c';
*(FCNN_2L_W_1out_FBALL_22_21->name+39)='t';
*(FCNN_2L_W_1out_FBALL_22_21->name+40)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+41)='d';
*(FCNN_2L_W_1out_FBALL_22_21->name+42)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+43)='N';
*(FCNN_2L_W_1out_FBALL_22_21->name+44)='N';
*(FCNN_2L_W_1out_FBALL_22_21->name+45)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+46)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+47)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+48)='L';
*(FCNN_2L_W_1out_FBALL_22_21->name+49)='a';
*(FCNN_2L_W_1out_FBALL_22_21->name+50)='y';
*(FCNN_2L_W_1out_FBALL_22_21->name+51)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+52)='r';
*(FCNN_2L_W_1out_FBALL_22_21->name+53)='s';
*(FCNN_2L_W_1out_FBALL_22_21->name+54)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+55)='r';
*(FCNN_2L_W_1out_FBALL_22_21->name+56)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+57)='c';
*(FCNN_2L_W_1out_FBALL_22_21->name+58)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+59)='i';
*(FCNN_2L_W_1out_FBALL_22_21->name+60)='v';
*(FCNN_2L_W_1out_FBALL_22_21->name+61)='i';
*(FCNN_2L_W_1out_FBALL_22_21->name+62)='n';
*(FCNN_2L_W_1out_FBALL_22_21->name+63)='g';
*(FCNN_2L_W_1out_FBALL_22_21->name+64)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+65)='i';
*(FCNN_2L_W_1out_FBALL_22_21->name+66)='n';
*(FCNN_2L_W_1out_FBALL_22_21->name+67)='p';
*(FCNN_2L_W_1out_FBALL_22_21->name+68)='u';
*(FCNN_2L_W_1out_FBALL_22_21->name+69)='t';
*(FCNN_2L_W_1out_FBALL_22_21->name+70)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+71)='t';
*(FCNN_2L_W_1out_FBALL_22_21->name+72)='h';
*(FCNN_2L_W_1out_FBALL_22_21->name+73)='r';
*(FCNN_2L_W_1out_FBALL_22_21->name+74)='o';
*(FCNN_2L_W_1out_FBALL_22_21->name+75)='u';
*(FCNN_2L_W_1out_FBALL_22_21->name+76)='g';
*(FCNN_2L_W_1out_FBALL_22_21->name+77)='h';
*(FCNN_2L_W_1out_FBALL_22_21->name+78)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+79)='W';
*(FCNN_2L_W_1out_FBALL_22_21->name+80)='i';
*(FCNN_2L_W_1out_FBALL_22_21->name+81)='n';
*(FCNN_2L_W_1out_FBALL_22_21->name+82)='d';
*(FCNN_2L_W_1out_FBALL_22_21->name+83)='o';
*(FCNN_2L_W_1out_FBALL_22_21->name+84)='w';
*(FCNN_2L_W_1out_FBALL_22_21->name+85)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+86)='1';
*(FCNN_2L_W_1out_FBALL_22_21->name+87)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+88)='o';
*(FCNN_2L_W_1out_FBALL_22_21->name+89)='u';
*(FCNN_2L_W_1out_FBALL_22_21->name+90)='t';
*(FCNN_2L_W_1out_FBALL_22_21->name+91)='p';
*(FCNN_2L_W_1out_FBALL_22_21->name+92)='u';
*(FCNN_2L_W_1out_FBALL_22_21->name+93)='t';
*(FCNN_2L_W_1out_FBALL_22_21->name+94)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+95)='f';
*(FCNN_2L_W_1out_FBALL_22_21->name+96)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+97)='e';
*(FCNN_2L_W_1out_FBALL_22_21->name+98)='d';
*(FCNN_2L_W_1out_FBALL_22_21->name+99)='b';
*(FCNN_2L_W_1out_FBALL_22_21->name+100)='a';
*(FCNN_2L_W_1out_FBALL_22_21->name+101)='c';
*(FCNN_2L_W_1out_FBALL_22_21->name+102)='k';
*(FCNN_2L_W_1out_FBALL_22_21->name+103)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+104)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+105)='>';
*(FCNN_2L_W_1out_FBALL_22_21->name+106)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+107)='_';
*(FCNN_2L_W_1out_FBALL_22_21->name+108)='2';
*(FCNN_2L_W_1out_FBALL_22_21->name+109)='>';
*(FCNN_2L_W_1out_FBALL_22_21->name+110)='1';
*(FCNN_2L_W_1out_FBALL_22_21->name+111)=')';
*(FCNN_2L_W_1out_FBALL_22_21->name+112)=' ';
FCNN_2L_W_1out_FBALL_22_21->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_22_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_22_21->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FBALL_22_21->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_22_21->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_22_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_22_21->recurrence=T;
FCNN_2L_W_1out_FBALL_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_W_1out_FBALL_22_21->source=MAI((long int)FCNN_2L_W_1out_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22_21->source+0)=2;
*(FCNN_2L_W_1out_FBALL_22_21->source+1)=2;
FCNN_2L_W_1out_FBALL_22_21->destination=MAI((long int)FCNN_2L_W_1out_FBALL_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22_21->destination+0)=2;
*(FCNN_2L_W_1out_FBALL_22_21->destination+1)=1;
FCNN_2L_W_1out_FBALL_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21->create_neuron==0) exit_handling(66,1);
*(FCNN_2L_W_1out_FBALL_22_21->create_neuron+0)=create_FCNN_2L_1out_FBALL_22_21;
FCNN_2L_W_1out_FBALL_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_22_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_22_21->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21->node_linear_output==0) exit_handling(66,2);
*(FCNN_2L_W_1out_FBALL_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_22_21->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21->node_output==0) exit_handling(66,3);
*(FCNN_2L_W_1out_FBALL_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21->node_output_derivation==0) exit_handling(66,4);
*(FCNN_2L_W_1out_FBALL_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_22_21->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21->firing_neuron==0) exit_handling(66,5);
*(FCNN_2L_W_1out_FBALL_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FBALL_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FBALL_22_21->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21->create_learning_algorithm==0) exit_handling(66,6);
*(FCNN_2L_W_1out_FBALL_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_22_21);
} /* ; */
/* setting up FCNN_2L_W_1out_FBALL_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FBALL_22_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback to all (means all nodes from feedback source are producing feedback onto all nodes of feedback destination) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FBALL_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FBALL_22_21_11;
FCNN_2L_W_1out_FBALL_22_21_11=MANTD((long int)1);
FCNN_2L_W_1out_FBALL_22_21_11->name=MAC((long int)120);
*(FCNN_2L_W_1out_FBALL_22_21_11->name+0)='F';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+1)='C';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+2)='N';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+3)='N';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+4)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+5)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+6)='L';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+7)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+8)='W';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+9)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+10)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+11)='o';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+12)='u';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+13)='t';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+14)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+15)='F';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+16)='B';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+17)='A';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+18)='L';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+19)='L';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+20)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+21)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+22)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+23)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+24)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+25)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+26)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+27)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+28)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+29)='(';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+30)='F';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+31)='u';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+32)='l';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+33)='l';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+34)='y';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+35)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+36)='C';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+37)='o';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+38)='n';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+39)='n';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+40)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+41)='c';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+42)='t';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+43)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+44)='d';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+45)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+46)='N';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+47)='N';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+48)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+49)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+50)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+51)='L';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+52)='a';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+53)='y';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+54)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+55)='r';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+56)='s';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+57)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+58)='r';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+59)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+60)='c';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+61)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+62)='i';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+63)='v';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+64)='i';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+65)='n';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+66)='g';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+67)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+68)='i';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+69)='n';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+70)='p';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+71)='u';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+72)='t';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+73)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+74)='t';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+75)='h';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+76)='r';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+77)='o';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+78)='u';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+79)='g';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+80)='h';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+81)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+82)='W';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+83)='i';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+84)='n';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+85)='d';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+86)='o';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+87)='w';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+88)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+89)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+90)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+91)='o';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+92)='u';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+93)='t';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+94)='p';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+95)='u';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+96)='t';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+97)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+98)='f';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+99)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+100)='e';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+101)='d';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+102)='b';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+103)='a';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+104)='c';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+105)='k';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+106)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+107)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+108)='>';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+109)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+110)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+111)='2';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+112)='>';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+113)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+114)='_';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+115)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+116)='>';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+117)='1';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+118)=')';
*(FCNN_2L_W_1out_FBALL_22_21_11->name+119)=' ';
FCNN_2L_W_1out_FBALL_22_21_11->number_of_Levels=2;
FCNN_2L_W_1out_FBALL_22_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FBALL_22_21_11->prepare_input()) plus inputs from feedbacks */
FCNN_2L_W_1out_FBALL_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FBALL_22_21_11->number_of_Levels);
*(FCNN_2L_W_1out_FBALL_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FBALL_22_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FBALL_22_21_11->recurrence=T;
FCNN_2L_W_1out_FBALL_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_W_1out_FBALL_22_21_11->source=MAI((long int)FCNN_2L_W_1out_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22_21_11->source+0)=2;
*(FCNN_2L_W_1out_FBALL_22_21_11->source+1)=2;
*(FCNN_2L_W_1out_FBALL_22_21_11->source+2)=1;
FCNN_2L_W_1out_FBALL_22_21_11->destination=MAI((long int)FCNN_2L_W_1out_FBALL_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FBALL_22_21_11->destination+0)=2;
*(FCNN_2L_W_1out_FBALL_22_21_11->destination+1)=1;
*(FCNN_2L_W_1out_FBALL_22_21_11->destination+2)=1;
FCNN_2L_W_1out_FBALL_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FBALL_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21_11->create_neuron==0) exit_handling(67,1);
*(FCNN_2L_W_1out_FBALL_22_21_11->create_neuron+0)=create_FCNN_2L_1out_FBALL_22_21_11;
FCNN_2L_W_1out_FBALL_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FBALL_22_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FBALL_22_21_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FBALL_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21_11->node_linear_output==0) exit_handling(67,2);
*(FCNN_2L_W_1out_FBALL_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FBALL_22_21_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FBALL_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21_11->node_output==0) exit_handling(67,3);
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FBALL_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21_11->node_output_derivation==0) exit_handling(67,4);
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FBALL_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FBALL_22_21_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FBALL_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21_11->firing_neuron==0) exit_handling(67,5);
*(FCNN_2L_W_1out_FBALL_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FBALL_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FBALL_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FBALL_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FBALL_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FBALL_22_21_11->create_learning_algorithm==0) exit_handling(67,6);
*(FCNN_2L_W_1out_FBALL_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FBALL_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FBALL_22_21_11);
} /* ; */
/* setting up FCNN_2L_FB1_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_11 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_11;
FCNN_2L_FB1_11=MANTD((long int)1);
FCNN_2L_FB1_11->name=MAC((long int)57);
*(FCNN_2L_FB1_11->name+0)='F';
*(FCNN_2L_FB1_11->name+1)='C';
*(FCNN_2L_FB1_11->name+2)='N';
*(FCNN_2L_FB1_11->name+3)='N';
*(FCNN_2L_FB1_11->name+4)='_';
*(FCNN_2L_FB1_11->name+5)='2';
*(FCNN_2L_FB1_11->name+6)='L';
*(FCNN_2L_FB1_11->name+7)='_';
*(FCNN_2L_FB1_11->name+8)='F';
*(FCNN_2L_FB1_11->name+9)='B';
*(FCNN_2L_FB1_11->name+10)='1';
*(FCNN_2L_FB1_11->name+11)='_';
*(FCNN_2L_FB1_11->name+12)='1';
*(FCNN_2L_FB1_11->name+13)='1';
*(FCNN_2L_FB1_11->name+14)='(';
*(FCNN_2L_FB1_11->name+15)='F';
*(FCNN_2L_FB1_11->name+16)='u';
*(FCNN_2L_FB1_11->name+17)='l';
*(FCNN_2L_FB1_11->name+18)='l';
*(FCNN_2L_FB1_11->name+19)='y';
*(FCNN_2L_FB1_11->name+20)='_';
*(FCNN_2L_FB1_11->name+21)='C';
*(FCNN_2L_FB1_11->name+22)='o';
*(FCNN_2L_FB1_11->name+23)='n';
*(FCNN_2L_FB1_11->name+24)='n';
*(FCNN_2L_FB1_11->name+25)='e';
*(FCNN_2L_FB1_11->name+26)='c';
*(FCNN_2L_FB1_11->name+27)='t';
*(FCNN_2L_FB1_11->name+28)='e';
*(FCNN_2L_FB1_11->name+29)='d';
*(FCNN_2L_FB1_11->name+30)='_';
*(FCNN_2L_FB1_11->name+31)='N';
*(FCNN_2L_FB1_11->name+32)='N';
*(FCNN_2L_FB1_11->name+33)='_';
*(FCNN_2L_FB1_11->name+34)='2';
*(FCNN_2L_FB1_11->name+35)='_';
*(FCNN_2L_FB1_11->name+36)='L';
*(FCNN_2L_FB1_11->name+37)='a';
*(FCNN_2L_FB1_11->name+38)='y';
*(FCNN_2L_FB1_11->name+39)='e';
*(FCNN_2L_FB1_11->name+40)='r';
*(FCNN_2L_FB1_11->name+41)='s';
*(FCNN_2L_FB1_11->name+42)='_';
*(FCNN_2L_FB1_11->name+43)='f';
*(FCNN_2L_FB1_11->name+44)='e';
*(FCNN_2L_FB1_11->name+45)='e';
*(FCNN_2L_FB1_11->name+46)='d';
*(FCNN_2L_FB1_11->name+47)='b';
*(FCNN_2L_FB1_11->name+48)='a';
*(FCNN_2L_FB1_11->name+49)='c';
*(FCNN_2L_FB1_11->name+50)='k';
*(FCNN_2L_FB1_11->name+51)='_';
*(FCNN_2L_FB1_11->name+52)='1';
*(FCNN_2L_FB1_11->name+53)='>';
*(FCNN_2L_FB1_11->name+54)='1';
*(FCNN_2L_FB1_11->name+55)=')';
*(FCNN_2L_FB1_11->name+56)=' ';
FCNN_2L_FB1_11->number_of_Levels=2;
FCNN_2L_FB1_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FB1_11->nodes_per_Level=MAI((long int)FCNN_2L_FB1_11->number_of_Levels);
*(FCNN_2L_FB1_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_11->recurrence=T;
FCNN_2L_FB1_11->number_of_recurrent_connected_layers=1;
FCNN_2L_FB1_11->source=MAI((long int)FCNN_2L_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_11->source+0)=1;
FCNN_2L_FB1_11->destination=MAI((long int)FCNN_2L_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_11->destination+0)=1;
FCNN_2L_FB1_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_11->create_neuron==0) exit_handling(68,1);
*(FCNN_2L_FB1_11->create_neuron+0)=create_FCNN_2L_FB1_11;
FCNN_2L_FB1_11->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_11->prepare_input=0;
FCNN_2L_FB1_11->number_linear_output_functions=3;
FCNN_2L_FB1_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_11->node_linear_output==0) exit_handling(68,2);
*(FCNN_2L_FB1_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_11->number_of_node_output_functions=4;
FCNN_2L_FB1_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_11->node_output==0) exit_handling(68,3);
*(FCNN_2L_FB1_11->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_11->node_output_derivation==0) exit_handling(68,4);
*(FCNN_2L_FB1_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_11->number_of_firing_functions=2;
FCNN_2L_FB1_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_11->firing_neuron==0) exit_handling(68,5);
*(FCNN_2L_FB1_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FB1_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FB1_11->number_of_learning_algorithms=2;
FCNN_2L_FB1_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_11->create_learning_algorithm==0) exit_handling(68,6);
*(FCNN_2L_FB1_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_11);
} /* ; */
/* setting up FCNN_2L_FB1_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_22 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_22;
FCNN_2L_FB1_22=MANTD((long int)1);
FCNN_2L_FB1_22->name=MAC((long int)57);
*(FCNN_2L_FB1_22->name+0)='F';
*(FCNN_2L_FB1_22->name+1)='C';
*(FCNN_2L_FB1_22->name+2)='N';
*(FCNN_2L_FB1_22->name+3)='N';
*(FCNN_2L_FB1_22->name+4)='_';
*(FCNN_2L_FB1_22->name+5)='2';
*(FCNN_2L_FB1_22->name+6)='L';
*(FCNN_2L_FB1_22->name+7)='_';
*(FCNN_2L_FB1_22->name+8)='F';
*(FCNN_2L_FB1_22->name+9)='B';
*(FCNN_2L_FB1_22->name+10)='1';
*(FCNN_2L_FB1_22->name+11)='_';
*(FCNN_2L_FB1_22->name+12)='2';
*(FCNN_2L_FB1_22->name+13)='2';
*(FCNN_2L_FB1_22->name+14)='(';
*(FCNN_2L_FB1_22->name+15)='F';
*(FCNN_2L_FB1_22->name+16)='u';
*(FCNN_2L_FB1_22->name+17)='l';
*(FCNN_2L_FB1_22->name+18)='l';
*(FCNN_2L_FB1_22->name+19)='y';
*(FCNN_2L_FB1_22->name+20)='_';
*(FCNN_2L_FB1_22->name+21)='C';
*(FCNN_2L_FB1_22->name+22)='o';
*(FCNN_2L_FB1_22->name+23)='n';
*(FCNN_2L_FB1_22->name+24)='n';
*(FCNN_2L_FB1_22->name+25)='e';
*(FCNN_2L_FB1_22->name+26)='c';
*(FCNN_2L_FB1_22->name+27)='t';
*(FCNN_2L_FB1_22->name+28)='e';
*(FCNN_2L_FB1_22->name+29)='d';
*(FCNN_2L_FB1_22->name+30)='_';
*(FCNN_2L_FB1_22->name+31)='N';
*(FCNN_2L_FB1_22->name+32)='N';
*(FCNN_2L_FB1_22->name+33)='_';
*(FCNN_2L_FB1_22->name+34)='2';
*(FCNN_2L_FB1_22->name+35)='_';
*(FCNN_2L_FB1_22->name+36)='L';
*(FCNN_2L_FB1_22->name+37)='a';
*(FCNN_2L_FB1_22->name+38)='y';
*(FCNN_2L_FB1_22->name+39)='e';
*(FCNN_2L_FB1_22->name+40)='r';
*(FCNN_2L_FB1_22->name+41)='s';
*(FCNN_2L_FB1_22->name+42)='_';
*(FCNN_2L_FB1_22->name+43)='f';
*(FCNN_2L_FB1_22->name+44)='e';
*(FCNN_2L_FB1_22->name+45)='e';
*(FCNN_2L_FB1_22->name+46)='d';
*(FCNN_2L_FB1_22->name+47)='b';
*(FCNN_2L_FB1_22->name+48)='a';
*(FCNN_2L_FB1_22->name+49)='c';
*(FCNN_2L_FB1_22->name+50)='k';
*(FCNN_2L_FB1_22->name+51)='_';
*(FCNN_2L_FB1_22->name+52)='2';
*(FCNN_2L_FB1_22->name+53)='>';
*(FCNN_2L_FB1_22->name+54)='2';
*(FCNN_2L_FB1_22->name+55)=')';
*(FCNN_2L_FB1_22->name+56)=' ';
FCNN_2L_FB1_22->number_of_Levels=2;
FCNN_2L_FB1_22->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
FCNN_2L_FB1_22->nodes_per_Level=MAI((long int)FCNN_2L_FB1_22->number_of_Levels);
*(FCNN_2L_FB1_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_22->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_22->recurrence=T;
FCNN_2L_FB1_22->number_of_recurrent_connected_layers=1;
FCNN_2L_FB1_22->source=MAI((long int)FCNN_2L_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22->source+0)=2;
FCNN_2L_FB1_22->destination=MAI((long int)FCNN_2L_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22->destination+0)=2;
FCNN_2L_FB1_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_22->create_neuron==0) exit_handling(69,1);
*(FCNN_2L_FB1_22->create_neuron+0)=create_FCNN_2L_FB1_22;
FCNN_2L_FB1_22->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_22->prepare_input=0;
FCNN_2L_FB1_22->number_linear_output_functions=3;
FCNN_2L_FB1_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22->node_linear_output==0) exit_handling(69,2);
*(FCNN_2L_FB1_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_22->number_of_node_output_functions=4;
FCNN_2L_FB1_22->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22->node_output==0) exit_handling(69,3);
*(FCNN_2L_FB1_22->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22->node_output_derivation==0) exit_handling(69,4);
*(FCNN_2L_FB1_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_22->number_of_firing_functions=2;
FCNN_2L_FB1_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_22->firing_neuron==0) exit_handling(69,5);
*(FCNN_2L_FB1_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FB1_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FB1_22->number_of_learning_algorithms=2;
FCNN_2L_FB1_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_22->create_learning_algorithm==0) exit_handling(69,6);
*(FCNN_2L_FB1_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_22);
} /* ; */
/* setting up FCNN_2L_FB1_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_21 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer on 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_21;
FCNN_2L_FB1_21=MANTD((long int)1);
FCNN_2L_FB1_21->name=MAC((long int)57);
*(FCNN_2L_FB1_21->name+0)='F';
*(FCNN_2L_FB1_21->name+1)='C';
*(FCNN_2L_FB1_21->name+2)='N';
*(FCNN_2L_FB1_21->name+3)='N';
*(FCNN_2L_FB1_21->name+4)='_';
*(FCNN_2L_FB1_21->name+5)='2';
*(FCNN_2L_FB1_21->name+6)='L';
*(FCNN_2L_FB1_21->name+7)='_';
*(FCNN_2L_FB1_21->name+8)='F';
*(FCNN_2L_FB1_21->name+9)='B';
*(FCNN_2L_FB1_21->name+10)='1';
*(FCNN_2L_FB1_21->name+11)='_';
*(FCNN_2L_FB1_21->name+12)='2';
*(FCNN_2L_FB1_21->name+13)='1';
*(FCNN_2L_FB1_21->name+14)='(';
*(FCNN_2L_FB1_21->name+15)='F';
*(FCNN_2L_FB1_21->name+16)='u';
*(FCNN_2L_FB1_21->name+17)='l';
*(FCNN_2L_FB1_21->name+18)='l';
*(FCNN_2L_FB1_21->name+19)='y';
*(FCNN_2L_FB1_21->name+20)='_';
*(FCNN_2L_FB1_21->name+21)='C';
*(FCNN_2L_FB1_21->name+22)='o';
*(FCNN_2L_FB1_21->name+23)='n';
*(FCNN_2L_FB1_21->name+24)='n';
*(FCNN_2L_FB1_21->name+25)='e';
*(FCNN_2L_FB1_21->name+26)='c';
*(FCNN_2L_FB1_21->name+27)='t';
*(FCNN_2L_FB1_21->name+28)='e';
*(FCNN_2L_FB1_21->name+29)='d';
*(FCNN_2L_FB1_21->name+30)='_';
*(FCNN_2L_FB1_21->name+31)='N';
*(FCNN_2L_FB1_21->name+32)='N';
*(FCNN_2L_FB1_21->name+33)='_';
*(FCNN_2L_FB1_21->name+34)='2';
*(FCNN_2L_FB1_21->name+35)='_';
*(FCNN_2L_FB1_21->name+36)='L';
*(FCNN_2L_FB1_21->name+37)='a';
*(FCNN_2L_FB1_21->name+38)='y';
*(FCNN_2L_FB1_21->name+39)='e';
*(FCNN_2L_FB1_21->name+40)='r';
*(FCNN_2L_FB1_21->name+41)='s';
*(FCNN_2L_FB1_21->name+42)='_';
*(FCNN_2L_FB1_21->name+43)='f';
*(FCNN_2L_FB1_21->name+44)='e';
*(FCNN_2L_FB1_21->name+45)='e';
*(FCNN_2L_FB1_21->name+46)='d';
*(FCNN_2L_FB1_21->name+47)='b';
*(FCNN_2L_FB1_21->name+48)='a';
*(FCNN_2L_FB1_21->name+49)='c';
*(FCNN_2L_FB1_21->name+50)='k';
*(FCNN_2L_FB1_21->name+51)='_';
*(FCNN_2L_FB1_21->name+52)='2';
*(FCNN_2L_FB1_21->name+53)='>';
*(FCNN_2L_FB1_21->name+54)='1';
*(FCNN_2L_FB1_21->name+55)=')';
*(FCNN_2L_FB1_21->name+56)=' ';
FCNN_2L_FB1_21->number_of_Levels=2;
FCNN_2L_FB1_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FB1_21->nodes_per_Level=MAI((long int)FCNN_2L_FB1_21->number_of_Levels);
*(FCNN_2L_FB1_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_21->recurrence=T;
FCNN_2L_FB1_21->number_of_recurrent_connected_layers=1;
FCNN_2L_FB1_21->source=MAI((long int)FCNN_2L_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_21->source+0)=2;
FCNN_2L_FB1_21->destination=MAI((long int)FCNN_2L_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_21->destination+0)=1;
FCNN_2L_FB1_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_21->create_neuron==0) exit_handling(70,1);
*(FCNN_2L_FB1_21->create_neuron+0)=create_FCNN_2L_FB1_21;
FCNN_2L_FB1_21->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_21->prepare_input=0;
FCNN_2L_FB1_21->number_linear_output_functions=3;
FCNN_2L_FB1_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_21->node_linear_output==0) exit_handling(70,2);
*(FCNN_2L_FB1_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_21->number_of_node_output_functions=4;
FCNN_2L_FB1_21->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_21->node_output==0) exit_handling(70,3);
*(FCNN_2L_FB1_21->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_21->node_output_derivation==0) exit_handling(70,4);
*(FCNN_2L_FB1_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_21->number_of_firing_functions=2;
FCNN_2L_FB1_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_21->firing_neuron==0) exit_handling(70,5);
*(FCNN_2L_FB1_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_FB1_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_FB1_21->number_of_learning_algorithms=2;
FCNN_2L_FB1_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_21->create_learning_algorithm==0) exit_handling(70,6);
*(FCNN_2L_FB1_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_21);
} /* ; */
/* setting up FCNN_2L_FB1_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_22_11 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_22_11;
FCNN_2L_FB1_22_11=MANTD((long int)1);
FCNN_2L_FB1_22_11->name=MAC((long int)68);
*(FCNN_2L_FB1_22_11->name+0)='F';
*(FCNN_2L_FB1_22_11->name+1)='C';
*(FCNN_2L_FB1_22_11->name+2)='N';
*(FCNN_2L_FB1_22_11->name+3)='N';
*(FCNN_2L_FB1_22_11->name+4)='_';
*(FCNN_2L_FB1_22_11->name+5)='2';
*(FCNN_2L_FB1_22_11->name+6)='L';
*(FCNN_2L_FB1_22_11->name+7)='_';
*(FCNN_2L_FB1_22_11->name+8)='F';
*(FCNN_2L_FB1_22_11->name+9)='B';
*(FCNN_2L_FB1_22_11->name+10)='1';
*(FCNN_2L_FB1_22_11->name+11)='_';
*(FCNN_2L_FB1_22_11->name+12)='2';
*(FCNN_2L_FB1_22_11->name+13)='2';
*(FCNN_2L_FB1_22_11->name+14)='_';
*(FCNN_2L_FB1_22_11->name+15)='1';
*(FCNN_2L_FB1_22_11->name+16)='1';
*(FCNN_2L_FB1_22_11->name+17)='(';
*(FCNN_2L_FB1_22_11->name+18)='F';
*(FCNN_2L_FB1_22_11->name+19)='u';
*(FCNN_2L_FB1_22_11->name+20)='l';
*(FCNN_2L_FB1_22_11->name+21)='l';
*(FCNN_2L_FB1_22_11->name+22)='y';
*(FCNN_2L_FB1_22_11->name+23)='_';
*(FCNN_2L_FB1_22_11->name+24)='C';
*(FCNN_2L_FB1_22_11->name+25)='o';
*(FCNN_2L_FB1_22_11->name+26)='n';
*(FCNN_2L_FB1_22_11->name+27)='n';
*(FCNN_2L_FB1_22_11->name+28)='e';
*(FCNN_2L_FB1_22_11->name+29)='c';
*(FCNN_2L_FB1_22_11->name+30)='t';
*(FCNN_2L_FB1_22_11->name+31)='e';
*(FCNN_2L_FB1_22_11->name+32)='d';
*(FCNN_2L_FB1_22_11->name+33)='_';
*(FCNN_2L_FB1_22_11->name+34)='N';
*(FCNN_2L_FB1_22_11->name+35)='N';
*(FCNN_2L_FB1_22_11->name+36)='_';
*(FCNN_2L_FB1_22_11->name+37)='2';
*(FCNN_2L_FB1_22_11->name+38)='_';
*(FCNN_2L_FB1_22_11->name+39)='L';
*(FCNN_2L_FB1_22_11->name+40)='a';
*(FCNN_2L_FB1_22_11->name+41)='y';
*(FCNN_2L_FB1_22_11->name+42)='e';
*(FCNN_2L_FB1_22_11->name+43)='r';
*(FCNN_2L_FB1_22_11->name+44)='s';
*(FCNN_2L_FB1_22_11->name+45)='_';
*(FCNN_2L_FB1_22_11->name+46)='f';
*(FCNN_2L_FB1_22_11->name+47)='e';
*(FCNN_2L_FB1_22_11->name+48)='e';
*(FCNN_2L_FB1_22_11->name+49)='d';
*(FCNN_2L_FB1_22_11->name+50)='b';
*(FCNN_2L_FB1_22_11->name+51)='a';
*(FCNN_2L_FB1_22_11->name+52)='c';
*(FCNN_2L_FB1_22_11->name+53)='k';
*(FCNN_2L_FB1_22_11->name+54)='_';
*(FCNN_2L_FB1_22_11->name+55)='2';
*(FCNN_2L_FB1_22_11->name+56)='>';
*(FCNN_2L_FB1_22_11->name+57)='2';
*(FCNN_2L_FB1_22_11->name+58)='_';
*(FCNN_2L_FB1_22_11->name+59)='a';
*(FCNN_2L_FB1_22_11->name+60)='n';
*(FCNN_2L_FB1_22_11->name+61)='d';
*(FCNN_2L_FB1_22_11->name+62)='_';
*(FCNN_2L_FB1_22_11->name+63)='1';
*(FCNN_2L_FB1_22_11->name+64)='>';
*(FCNN_2L_FB1_22_11->name+65)='1';
*(FCNN_2L_FB1_22_11->name+66)=')';
*(FCNN_2L_FB1_22_11->name+67)=' ';
FCNN_2L_FB1_22_11->number_of_Levels=2;
FCNN_2L_FB1_22_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FB1_22_11->nodes_per_Level=MAI((long int)FCNN_2L_FB1_22_11->number_of_Levels);
*(FCNN_2L_FB1_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_22_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_22_11->recurrence=T;
FCNN_2L_FB1_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_FB1_22_11->source=MAI((long int)FCNN_2L_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22_11->source+0)=2;
*(FCNN_2L_FB1_22_11->source+1)=1;
FCNN_2L_FB1_22_11->destination=MAI((long int)FCNN_2L_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22_11->destination+0)=2;
*(FCNN_2L_FB1_22_11->destination+1)=1;
FCNN_2L_FB1_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_22_11->create_neuron==0) exit_handling(71,1);
*(FCNN_2L_FB1_22_11->create_neuron+0)=create_FCNN_2L_FB1_22_11;
FCNN_2L_FB1_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_22_11->prepare_input=0;
FCNN_2L_FB1_22_11->number_linear_output_functions=3;
FCNN_2L_FB1_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_11->node_linear_output==0) exit_handling(71,2);
*(FCNN_2L_FB1_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_22_11->number_of_node_output_functions=4;
FCNN_2L_FB1_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_11->node_output==0) exit_handling(71,3);
*(FCNN_2L_FB1_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_11->node_output_derivation==0) exit_handling(71,4);
*(FCNN_2L_FB1_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_22_11->number_of_firing_functions=2;
FCNN_2L_FB1_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_22_11->firing_neuron==0) exit_handling(71,5);
*(FCNN_2L_FB1_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FB1_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FB1_22_11->number_of_learning_algorithms=2;
FCNN_2L_FB1_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_22_11->create_learning_algorithm==0) exit_handling(71,6);
*(FCNN_2L_FB1_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_22_11);
} /* ; */
/* setting up FCNN_2L_FB1_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_21_11 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer on 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_21_11;
FCNN_2L_FB1_21_11=MANTD((long int)1);
FCNN_2L_FB1_21_11->name=MAC((long int)68);
*(FCNN_2L_FB1_21_11->name+0)='F';
*(FCNN_2L_FB1_21_11->name+1)='C';
*(FCNN_2L_FB1_21_11->name+2)='N';
*(FCNN_2L_FB1_21_11->name+3)='N';
*(FCNN_2L_FB1_21_11->name+4)='_';
*(FCNN_2L_FB1_21_11->name+5)='2';
*(FCNN_2L_FB1_21_11->name+6)='L';
*(FCNN_2L_FB1_21_11->name+7)='_';
*(FCNN_2L_FB1_21_11->name+8)='F';
*(FCNN_2L_FB1_21_11->name+9)='B';
*(FCNN_2L_FB1_21_11->name+10)='1';
*(FCNN_2L_FB1_21_11->name+11)='_';
*(FCNN_2L_FB1_21_11->name+12)='2';
*(FCNN_2L_FB1_21_11->name+13)='1';
*(FCNN_2L_FB1_21_11->name+14)='_';
*(FCNN_2L_FB1_21_11->name+15)='1';
*(FCNN_2L_FB1_21_11->name+16)='1';
*(FCNN_2L_FB1_21_11->name+17)='(';
*(FCNN_2L_FB1_21_11->name+18)='F';
*(FCNN_2L_FB1_21_11->name+19)='u';
*(FCNN_2L_FB1_21_11->name+20)='l';
*(FCNN_2L_FB1_21_11->name+21)='l';
*(FCNN_2L_FB1_21_11->name+22)='y';
*(FCNN_2L_FB1_21_11->name+23)='_';
*(FCNN_2L_FB1_21_11->name+24)='C';
*(FCNN_2L_FB1_21_11->name+25)='o';
*(FCNN_2L_FB1_21_11->name+26)='n';
*(FCNN_2L_FB1_21_11->name+27)='n';
*(FCNN_2L_FB1_21_11->name+28)='e';
*(FCNN_2L_FB1_21_11->name+29)='c';
*(FCNN_2L_FB1_21_11->name+30)='t';
*(FCNN_2L_FB1_21_11->name+31)='e';
*(FCNN_2L_FB1_21_11->name+32)='d';
*(FCNN_2L_FB1_21_11->name+33)='_';
*(FCNN_2L_FB1_21_11->name+34)='N';
*(FCNN_2L_FB1_21_11->name+35)='N';
*(FCNN_2L_FB1_21_11->name+36)='_';
*(FCNN_2L_FB1_21_11->name+37)='2';
*(FCNN_2L_FB1_21_11->name+38)='_';
*(FCNN_2L_FB1_21_11->name+39)='L';
*(FCNN_2L_FB1_21_11->name+40)='a';
*(FCNN_2L_FB1_21_11->name+41)='y';
*(FCNN_2L_FB1_21_11->name+42)='e';
*(FCNN_2L_FB1_21_11->name+43)='r';
*(FCNN_2L_FB1_21_11->name+44)='s';
*(FCNN_2L_FB1_21_11->name+45)='_';
*(FCNN_2L_FB1_21_11->name+46)='f';
*(FCNN_2L_FB1_21_11->name+47)='e';
*(FCNN_2L_FB1_21_11->name+48)='e';
*(FCNN_2L_FB1_21_11->name+49)='d';
*(FCNN_2L_FB1_21_11->name+50)='b';
*(FCNN_2L_FB1_21_11->name+51)='a';
*(FCNN_2L_FB1_21_11->name+52)='c';
*(FCNN_2L_FB1_21_11->name+53)='k';
*(FCNN_2L_FB1_21_11->name+54)='_';
*(FCNN_2L_FB1_21_11->name+55)='2';
*(FCNN_2L_FB1_21_11->name+56)='>';
*(FCNN_2L_FB1_21_11->name+57)='1';
*(FCNN_2L_FB1_21_11->name+58)='_';
*(FCNN_2L_FB1_21_11->name+59)='a';
*(FCNN_2L_FB1_21_11->name+60)='n';
*(FCNN_2L_FB1_21_11->name+61)='d';
*(FCNN_2L_FB1_21_11->name+62)='_';
*(FCNN_2L_FB1_21_11->name+63)='1';
*(FCNN_2L_FB1_21_11->name+64)='>';
*(FCNN_2L_FB1_21_11->name+65)='1';
*(FCNN_2L_FB1_21_11->name+66)=')';
*(FCNN_2L_FB1_21_11->name+67)=' ';
FCNN_2L_FB1_21_11->number_of_Levels=2;
FCNN_2L_FB1_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback (from both itself and the second Level) */
FCNN_2L_FB1_21_11->nodes_per_Level=MAI((long int)FCNN_2L_FB1_21_11->number_of_Levels);
*(FCNN_2L_FB1_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_21_11->recurrence=T;
FCNN_2L_FB1_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_FB1_21_11->source=MAI((long int)FCNN_2L_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_21_11->source+0)=2;
*(FCNN_2L_FB1_21_11->source+1)=1;
FCNN_2L_FB1_21_11->destination=MAI((long int)FCNN_2L_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_21_11->destination+0)=1;
*(FCNN_2L_FB1_21_11->destination+1)=1;
FCNN_2L_FB1_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_21_11->create_neuron==0) exit_handling(72,1);
*(FCNN_2L_FB1_21_11->create_neuron+0)=create_FCNN_2L_FB1_21_11;
FCNN_2L_FB1_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_21_11->prepare_input=0;
FCNN_2L_FB1_21_11->number_linear_output_functions=3;
FCNN_2L_FB1_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_21_11->node_linear_output==0) exit_handling(72,2);
*(FCNN_2L_FB1_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_21_11->number_of_node_output_functions=4;
FCNN_2L_FB1_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_21_11->node_output==0) exit_handling(72,3);
*(FCNN_2L_FB1_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_21_11->node_output_derivation==0) exit_handling(72,4);
*(FCNN_2L_FB1_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_21_11->number_of_firing_functions=2;
FCNN_2L_FB1_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_21_11->firing_neuron==0) exit_handling(72,5);
*(FCNN_2L_FB1_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FB1_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FB1_21_11->number_of_learning_algorithms=2;
FCNN_2L_FB1_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_21_11->create_learning_algorithm==0) exit_handling(72,6);
*(FCNN_2L_FB1_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_21_11);
} /* ; */
/* setting up FCNN_2L_FB1_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_22_21 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer on 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_22_21;
FCNN_2L_FB1_22_21=MANTD((long int)1);
FCNN_2L_FB1_22_21->name=MAC((long int)68);
*(FCNN_2L_FB1_22_21->name+0)='F';
*(FCNN_2L_FB1_22_21->name+1)='C';
*(FCNN_2L_FB1_22_21->name+2)='N';
*(FCNN_2L_FB1_22_21->name+3)='N';
*(FCNN_2L_FB1_22_21->name+4)='_';
*(FCNN_2L_FB1_22_21->name+5)='2';
*(FCNN_2L_FB1_22_21->name+6)='L';
*(FCNN_2L_FB1_22_21->name+7)='_';
*(FCNN_2L_FB1_22_21->name+8)='F';
*(FCNN_2L_FB1_22_21->name+9)='B';
*(FCNN_2L_FB1_22_21->name+10)='1';
*(FCNN_2L_FB1_22_21->name+11)='_';
*(FCNN_2L_FB1_22_21->name+12)='2';
*(FCNN_2L_FB1_22_21->name+13)='2';
*(FCNN_2L_FB1_22_21->name+14)='_';
*(FCNN_2L_FB1_22_21->name+15)='2';
*(FCNN_2L_FB1_22_21->name+16)='1';
*(FCNN_2L_FB1_22_21->name+17)='(';
*(FCNN_2L_FB1_22_21->name+18)='F';
*(FCNN_2L_FB1_22_21->name+19)='u';
*(FCNN_2L_FB1_22_21->name+20)='l';
*(FCNN_2L_FB1_22_21->name+21)='l';
*(FCNN_2L_FB1_22_21->name+22)='y';
*(FCNN_2L_FB1_22_21->name+23)='_';
*(FCNN_2L_FB1_22_21->name+24)='C';
*(FCNN_2L_FB1_22_21->name+25)='o';
*(FCNN_2L_FB1_22_21->name+26)='n';
*(FCNN_2L_FB1_22_21->name+27)='n';
*(FCNN_2L_FB1_22_21->name+28)='e';
*(FCNN_2L_FB1_22_21->name+29)='c';
*(FCNN_2L_FB1_22_21->name+30)='t';
*(FCNN_2L_FB1_22_21->name+31)='e';
*(FCNN_2L_FB1_22_21->name+32)='d';
*(FCNN_2L_FB1_22_21->name+33)='_';
*(FCNN_2L_FB1_22_21->name+34)='N';
*(FCNN_2L_FB1_22_21->name+35)='N';
*(FCNN_2L_FB1_22_21->name+36)='_';
*(FCNN_2L_FB1_22_21->name+37)='2';
*(FCNN_2L_FB1_22_21->name+38)='_';
*(FCNN_2L_FB1_22_21->name+39)='L';
*(FCNN_2L_FB1_22_21->name+40)='a';
*(FCNN_2L_FB1_22_21->name+41)='y';
*(FCNN_2L_FB1_22_21->name+42)='e';
*(FCNN_2L_FB1_22_21->name+43)='r';
*(FCNN_2L_FB1_22_21->name+44)='s';
*(FCNN_2L_FB1_22_21->name+45)='_';
*(FCNN_2L_FB1_22_21->name+46)='f';
*(FCNN_2L_FB1_22_21->name+47)='e';
*(FCNN_2L_FB1_22_21->name+48)='e';
*(FCNN_2L_FB1_22_21->name+48)='d';
*(FCNN_2L_FB1_22_21->name+50)='b';
*(FCNN_2L_FB1_22_21->name+51)='a';
*(FCNN_2L_FB1_22_21->name+52)='c';
*(FCNN_2L_FB1_22_21->name+53)='k';
*(FCNN_2L_FB1_22_21->name+54)='_';
*(FCNN_2L_FB1_22_21->name+55)='2';
*(FCNN_2L_FB1_22_21->name+56)='>';
*(FCNN_2L_FB1_22_21->name+57)='2';
*(FCNN_2L_FB1_22_21->name+58)='_';
*(FCNN_2L_FB1_22_21->name+59)='a';
*(FCNN_2L_FB1_22_21->name+60)='n';
*(FCNN_2L_FB1_22_21->name+61)='d';
*(FCNN_2L_FB1_22_21->name+62)='_';
*(FCNN_2L_FB1_22_21->name+63)='2';
*(FCNN_2L_FB1_22_21->name+64)='>';
*(FCNN_2L_FB1_22_21->name+65)='1';
*(FCNN_2L_FB1_22_21->name+66)=')';
*(FCNN_2L_FB1_22_21->name+67)=' ';
FCNN_2L_FB1_22_21->number_of_Levels=2;
FCNN_2L_FB1_22_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FB1_22_21->nodes_per_Level=MAI((long int)FCNN_2L_FB1_22_21->number_of_Levels);
*(FCNN_2L_FB1_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_22_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_22_21->recurrence=T;
FCNN_2L_FB1_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_FB1_22_21->source=MAI((long int)FCNN_2L_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22_21->source+0)=2;
*(FCNN_2L_FB1_22_21->source+1)=2;
FCNN_2L_FB1_22_21->destination=MAI((long int)FCNN_2L_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22_21->destination+0)=2;
*(FCNN_2L_FB1_22_21->destination+1)=1;
FCNN_2L_FB1_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_22_21->create_neuron==0) exit_handling(73,1);
*(FCNN_2L_FB1_22_21->create_neuron+0)=create_FCNN_2L_FB1_22_21;
FCNN_2L_FB1_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_22_21->prepare_input=0;
FCNN_2L_FB1_22_21->number_linear_output_functions=3;
FCNN_2L_FB1_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21->node_linear_output==0) exit_handling(73,2);
*(FCNN_2L_FB1_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_22_21->number_of_node_output_functions=4;
FCNN_2L_FB1_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21->node_output==0) exit_handling(73,3);
*(FCNN_2L_FB1_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21->node_output_derivation==0) exit_handling(73,4);
*(FCNN_2L_FB1_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_22_21->number_of_firing_functions=2;
FCNN_2L_FB1_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21->firing_neuron==0) exit_handling(73,5);
*(FCNN_2L_FB1_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FB1_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FB1_22_21->number_of_learning_algorithms=2;
FCNN_2L_FB1_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_22_21->create_learning_algorithm==0) exit_handling(73,6);
*(FCNN_2L_FB1_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_22_21);
} /* ; */
/* setting up FCNN_2L_FB1_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_FB1_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_FB1_22_21_11 (Fully Connected Neural Network with 2 Layers and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_FB1_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_FB1_22_21_11;
FCNN_2L_FB1_22_21_11=MANTD((long int)1);
FCNN_2L_FB1_22_21_11->name=MAC((long int)79);
*(FCNN_2L_FB1_22_21_11->name+0)='F';
*(FCNN_2L_FB1_22_21_11->name+1)='C';
*(FCNN_2L_FB1_22_21_11->name+2)='N';
*(FCNN_2L_FB1_22_21_11->name+3)='N';
*(FCNN_2L_FB1_22_21_11->name+4)='_';
*(FCNN_2L_FB1_22_21_11->name+5)='2';
*(FCNN_2L_FB1_22_21_11->name+6)='L';
*(FCNN_2L_FB1_22_21_11->name+7)='_';
*(FCNN_2L_FB1_22_21_11->name+8)='F';
*(FCNN_2L_FB1_22_21_11->name+9)='B';
*(FCNN_2L_FB1_22_21_11->name+10)='1';
*(FCNN_2L_FB1_22_21_11->name+11)='_';
*(FCNN_2L_FB1_22_21_11->name+12)='2';
*(FCNN_2L_FB1_22_21_11->name+13)='2';
*(FCNN_2L_FB1_22_21_11->name+14)='_';
*(FCNN_2L_FB1_22_21_11->name+15)='2';
*(FCNN_2L_FB1_22_21_11->name+16)='1';
*(FCNN_2L_FB1_22_21_11->name+17)='_';
*(FCNN_2L_FB1_22_21_11->name+18)='1';
*(FCNN_2L_FB1_22_21_11->name+19)='1';
*(FCNN_2L_FB1_22_21_11->name+20)='(';
*(FCNN_2L_FB1_22_21_11->name+21)='F';
*(FCNN_2L_FB1_22_21_11->name+22)='u';
*(FCNN_2L_FB1_22_21_11->name+23)='l';
*(FCNN_2L_FB1_22_21_11->name+24)='l';
*(FCNN_2L_FB1_22_21_11->name+25)='y';
*(FCNN_2L_FB1_22_21_11->name+26)='_';
*(FCNN_2L_FB1_22_21_11->name+27)='C';
*(FCNN_2L_FB1_22_21_11->name+28)='o';
*(FCNN_2L_FB1_22_21_11->name+29)='n';
*(FCNN_2L_FB1_22_21_11->name+30)='n';
*(FCNN_2L_FB1_22_21_11->name+31)='e';
*(FCNN_2L_FB1_22_21_11->name+32)='c';
*(FCNN_2L_FB1_22_21_11->name+33)='t';
*(FCNN_2L_FB1_22_21_11->name+34)='e';
*(FCNN_2L_FB1_22_21_11->name+35)='d';
*(FCNN_2L_FB1_22_21_11->name+36)='_';
*(FCNN_2L_FB1_22_21_11->name+37)='N';
*(FCNN_2L_FB1_22_21_11->name+38)='N';
*(FCNN_2L_FB1_22_21_11->name+39)='_';
*(FCNN_2L_FB1_22_21_11->name+40)='2';
*(FCNN_2L_FB1_22_21_11->name+41)='_';
*(FCNN_2L_FB1_22_21_11->name+42)='L';
*(FCNN_2L_FB1_22_21_11->name+43)='a';
*(FCNN_2L_FB1_22_21_11->name+44)='y';
*(FCNN_2L_FB1_22_21_11->name+45)='e';
*(FCNN_2L_FB1_22_21_11->name+46)='r';
*(FCNN_2L_FB1_22_21_11->name+47)='s';
*(FCNN_2L_FB1_22_21_11->name+48)='_';
*(FCNN_2L_FB1_22_21_11->name+49)='f';
*(FCNN_2L_FB1_22_21_11->name+50)='e';
*(FCNN_2L_FB1_22_21_11->name+51)='e';
*(FCNN_2L_FB1_22_21_11->name+52)='d';
*(FCNN_2L_FB1_22_21_11->name+53)='b';
*(FCNN_2L_FB1_22_21_11->name+54)='a';
*(FCNN_2L_FB1_22_21_11->name+55)='c';
*(FCNN_2L_FB1_22_21_11->name+56)='k';
*(FCNN_2L_FB1_22_21_11->name+57)='_';
*(FCNN_2L_FB1_22_21_11->name+58)='2';
*(FCNN_2L_FB1_22_21_11->name+59)='>';
*(FCNN_2L_FB1_22_21_11->name+60)='2';
*(FCNN_2L_FB1_22_21_11->name+61)='_';
*(FCNN_2L_FB1_22_21_11->name+62)='a';
*(FCNN_2L_FB1_22_21_11->name+63)='n';
*(FCNN_2L_FB1_22_21_11->name+64)='d';
*(FCNN_2L_FB1_22_21_11->name+65)='_';
*(FCNN_2L_FB1_22_21_11->name+66)='2';
*(FCNN_2L_FB1_22_21_11->name+67)='>';
*(FCNN_2L_FB1_22_21_11->name+68)='1';
*(FCNN_2L_FB1_22_21_11->name+69)='_';
*(FCNN_2L_FB1_22_21_11->name+70)='a';
*(FCNN_2L_FB1_22_21_11->name+71)='n';
*(FCNN_2L_FB1_22_21_11->name+72)='d';
*(FCNN_2L_FB1_22_21_11->name+73)='_';
*(FCNN_2L_FB1_22_21_11->name+74)='1';
*(FCNN_2L_FB1_22_21_11->name+75)='>';
*(FCNN_2L_FB1_22_21_11->name+76)='1';
*(FCNN_2L_FB1_22_21_11->name+77)=')';
*(FCNN_2L_FB1_22_21_11->name+78)=' ';
FCNN_2L_FB1_22_21_11->number_of_Levels=2;
FCNN_2L_FB1_22_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_FB1_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_FB1_22_21_11->number_of_Levels);
*(FCNN_2L_FB1_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_FB1_22_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_FB1_22_21_11->recurrence=T;
FCNN_2L_FB1_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_FB1_22_21_11->source=MAI((long int)FCNN_2L_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22_21_11->source+0)=2;
*(FCNN_2L_FB1_22_21_11->source+1)=2;
*(FCNN_2L_FB1_22_21_11->source+2)=1;
FCNN_2L_FB1_22_21_11->destination=MAI((long int)FCNN_2L_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_FB1_22_21_11->destination+0)=2;
*(FCNN_2L_FB1_22_21_11->destination+1)=1;
*(FCNN_2L_FB1_22_21_11->destination+2)=1;
FCNN_2L_FB1_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_FB1_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_FB1_22_21_11->create_neuron==0) exit_handling(74,1);
*(FCNN_2L_FB1_22_21_11->create_neuron+0)=create_FCNN_2L_FB1_22_21_11;
FCNN_2L_FB1_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_FB1_22_21_11->prepare_input=0;
FCNN_2L_FB1_22_21_11->number_linear_output_functions=3;
FCNN_2L_FB1_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21_11->node_linear_output==0) exit_handling(74,2);
*(FCNN_2L_FB1_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_FB1_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_FB1_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_FB1_22_21_11->number_of_node_output_functions=4;
FCNN_2L_FB1_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21_11->node_output==0) exit_handling(74,3);
*(FCNN_2L_FB1_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_FB1_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_FB1_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_FB1_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_FB1_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21_11->node_output_derivation==0) exit_handling(74,4);
*(FCNN_2L_FB1_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_FB1_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_FB1_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_FB1_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_FB1_22_21_11->number_of_firing_functions=2;
FCNN_2L_FB1_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_FB1_22_21_11->firing_neuron==0) exit_handling(74,5);
*(FCNN_2L_FB1_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_FB1_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_FB1_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_FB1_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_FB1_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_FB1_22_21_11->create_learning_algorithm==0) exit_handling(74,6);
*(FCNN_2L_FB1_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_FB1_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_FB1_22_21_11);
} /* ; */
/* setting up FCNN_2L_W_FB1_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_11;
FCNN_2L_W_FB1_11=MANTD((long int)1);
FCNN_2L_W_FB1_11->name=MAC((long int)90);
*(FCNN_2L_W_FB1_11->name+0)='F';
*(FCNN_2L_W_FB1_11->name+1)='C';
*(FCNN_2L_W_FB1_11->name+2)='N';
*(FCNN_2L_W_FB1_11->name+3)='N';
*(FCNN_2L_W_FB1_11->name+4)='_';
*(FCNN_2L_W_FB1_11->name+5)='2';
*(FCNN_2L_W_FB1_11->name+6)='L';
*(FCNN_2L_W_FB1_11->name+7)='_';
*(FCNN_2L_W_FB1_11->name+8)='W';
*(FCNN_2L_W_FB1_11->name+9)='_';
*(FCNN_2L_W_FB1_11->name+10)='F';
*(FCNN_2L_W_FB1_11->name+11)='B';
*(FCNN_2L_W_FB1_11->name+12)='1';
*(FCNN_2L_W_FB1_11->name+13)='_';
*(FCNN_2L_W_FB1_11->name+14)='1';
*(FCNN_2L_W_FB1_11->name+15)='1';
*(FCNN_2L_W_FB1_11->name+16)='(';
*(FCNN_2L_W_FB1_11->name+17)='F';
*(FCNN_2L_W_FB1_11->name+18)='u';
*(FCNN_2L_W_FB1_11->name+19)='l';
*(FCNN_2L_W_FB1_11->name+20)='l';
*(FCNN_2L_W_FB1_11->name+21)='y';
*(FCNN_2L_W_FB1_11->name+22)='_';
*(FCNN_2L_W_FB1_11->name+23)='C';
*(FCNN_2L_W_FB1_11->name+24)='o';
*(FCNN_2L_W_FB1_11->name+25)='n';
*(FCNN_2L_W_FB1_11->name+26)='n';
*(FCNN_2L_W_FB1_11->name+27)='e';
*(FCNN_2L_W_FB1_11->name+28)='c';
*(FCNN_2L_W_FB1_11->name+29)='t';
*(FCNN_2L_W_FB1_11->name+30)='e';
*(FCNN_2L_W_FB1_11->name+31)='d';
*(FCNN_2L_W_FB1_11->name+32)='_';
*(FCNN_2L_W_FB1_11->name+33)='N';
*(FCNN_2L_W_FB1_11->name+34)='N';
*(FCNN_2L_W_FB1_11->name+35)='_';
*(FCNN_2L_W_FB1_11->name+36)='2';
*(FCNN_2L_W_FB1_11->name+37)='_';
*(FCNN_2L_W_FB1_11->name+38)='L';
*(FCNN_2L_W_FB1_11->name+39)='a';
*(FCNN_2L_W_FB1_11->name+40)='y';
*(FCNN_2L_W_FB1_11->name+41)='e';
*(FCNN_2L_W_FB1_11->name+42)='r';
*(FCNN_2L_W_FB1_11->name+43)='s';
*(FCNN_2L_W_FB1_11->name+44)='_';
*(FCNN_2L_W_FB1_11->name+45)='r';
*(FCNN_2L_W_FB1_11->name+46)='e';
*(FCNN_2L_W_FB1_11->name+47)='c';
*(FCNN_2L_W_FB1_11->name+48)='e';
*(FCNN_2L_W_FB1_11->name+49)='i';
*(FCNN_2L_W_FB1_11->name+50)='v';
*(FCNN_2L_W_FB1_11->name+51)='i';
*(FCNN_2L_W_FB1_11->name+52)='n';
*(FCNN_2L_W_FB1_11->name+53)='g';
*(FCNN_2L_W_FB1_11->name+54)='_';
*(FCNN_2L_W_FB1_11->name+55)='i';
*(FCNN_2L_W_FB1_11->name+56)='n';
*(FCNN_2L_W_FB1_11->name+57)='p';
*(FCNN_2L_W_FB1_11->name+58)='u';
*(FCNN_2L_W_FB1_11->name+59)='t';
*(FCNN_2L_W_FB1_11->name+60)='_';
*(FCNN_2L_W_FB1_11->name+61)='t';
*(FCNN_2L_W_FB1_11->name+62)='h';
*(FCNN_2L_W_FB1_11->name+63)='r';
*(FCNN_2L_W_FB1_11->name+64)='o';
*(FCNN_2L_W_FB1_11->name+65)='u';
*(FCNN_2L_W_FB1_11->name+66)='g';
*(FCNN_2L_W_FB1_11->name+67)='h';
*(FCNN_2L_W_FB1_11->name+68)='_';
*(FCNN_2L_W_FB1_11->name+69)='W';
*(FCNN_2L_W_FB1_11->name+70)='i';
*(FCNN_2L_W_FB1_11->name+71)='n';
*(FCNN_2L_W_FB1_11->name+72)='d';
*(FCNN_2L_W_FB1_11->name+73)='o';
*(FCNN_2L_W_FB1_11->name+74)='w';
*(FCNN_2L_W_FB1_11->name+75)='_';
*(FCNN_2L_W_FB1_11->name+76)='f';
*(FCNN_2L_W_FB1_11->name+77)='e';
*(FCNN_2L_W_FB1_11->name+78)='e';
*(FCNN_2L_W_FB1_11->name+79)='d';
*(FCNN_2L_W_FB1_11->name+80)='b';
*(FCNN_2L_W_FB1_11->name+81)='a';
*(FCNN_2L_W_FB1_11->name+82)='c';
*(FCNN_2L_W_FB1_11->name+83)='k';
*(FCNN_2L_W_FB1_11->name+84)='_';
*(FCNN_2L_W_FB1_11->name+85)='1';
*(FCNN_2L_W_FB1_11->name+86)='>';
*(FCNN_2L_W_FB1_11->name+87)='1';
*(FCNN_2L_W_FB1_11->name+88)=')';
*(FCNN_2L_W_FB1_11->name+89)=' ';
FCNN_2L_W_FB1_11->number_of_Levels=2;
FCNN_2L_W_FB1_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_11->prepare_input()) as well from feedback */
FCNN_2L_W_FB1_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_11->number_of_Levels);
*(FCNN_2L_W_FB1_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_11->recurrence=T;
FCNN_2L_W_FB1_11->number_of_recurrent_connected_layers=1;
FCNN_2L_W_FB1_11->source=MAI((long int)FCNN_2L_W_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_11->source+0)=1;
FCNN_2L_W_FB1_11->destination=MAI((long int)FCNN_2L_W_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_11->destination+0)=1;
FCNN_2L_W_FB1_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_11->create_neuron==0) exit_handling(75,1);
*(FCNN_2L_W_FB1_11->create_neuron+0)=create_FCNN_2L_FB1_11;
FCNN_2L_W_FB1_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_11->number_linear_output_functions=3;
FCNN_2L_W_FB1_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_11->node_linear_output==0) exit_handling(75,2);
*(FCNN_2L_W_FB1_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_11->number_of_node_output_functions=4;
FCNN_2L_W_FB1_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_11->node_output==0) exit_handling(75,3);
*(FCNN_2L_W_FB1_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_11->node_output_derivation==0) exit_handling(75,4);
*(FCNN_2L_W_FB1_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_11->number_of_firing_functions=2;
FCNN_2L_W_FB1_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_11->firing_neuron==0) exit_handling(75,5);
*(FCNN_2L_W_FB1_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FB1_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FB1_11->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_11->create_learning_algorithm==0) exit_handling(75,6);
*(FCNN_2L_W_FB1_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_11);
} /* ; */
/* setting up FCNN_2L_W_FB1_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_22 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_22;
FCNN_2L_W_FB1_22=MANTD((long int)1);
FCNN_2L_W_FB1_22->name=MAC((long int)90);
*(FCNN_2L_W_FB1_22->name+0)='F';
*(FCNN_2L_W_FB1_22->name+1)='C';
*(FCNN_2L_W_FB1_22->name+2)='N';
*(FCNN_2L_W_FB1_22->name+3)='N';
*(FCNN_2L_W_FB1_22->name+4)='_';
*(FCNN_2L_W_FB1_22->name+5)='2';
*(FCNN_2L_W_FB1_22->name+6)='L';
*(FCNN_2L_W_FB1_22->name+7)='_';
*(FCNN_2L_W_FB1_22->name+8)='W';
*(FCNN_2L_W_FB1_22->name+9)='_';
*(FCNN_2L_W_FB1_22->name+10)='F';
*(FCNN_2L_W_FB1_22->name+11)='B';
*(FCNN_2L_W_FB1_22->name+12)='1';
*(FCNN_2L_W_FB1_22->name+13)='_';
*(FCNN_2L_W_FB1_22->name+14)='2';
*(FCNN_2L_W_FB1_22->name+15)='2';
*(FCNN_2L_W_FB1_22->name+16)='(';
*(FCNN_2L_W_FB1_22->name+17)='F';
*(FCNN_2L_W_FB1_22->name+18)='u';
*(FCNN_2L_W_FB1_22->name+19)='l';
*(FCNN_2L_W_FB1_22->name+20)='l';
*(FCNN_2L_W_FB1_22->name+21)='y';
*(FCNN_2L_W_FB1_22->name+22)='_';
*(FCNN_2L_W_FB1_22->name+23)='C';
*(FCNN_2L_W_FB1_22->name+24)='o';
*(FCNN_2L_W_FB1_22->name+25)='n';
*(FCNN_2L_W_FB1_22->name+26)='n';
*(FCNN_2L_W_FB1_22->name+27)='e';
*(FCNN_2L_W_FB1_22->name+28)='c';
*(FCNN_2L_W_FB1_22->name+29)='t';
*(FCNN_2L_W_FB1_22->name+30)='e';
*(FCNN_2L_W_FB1_22->name+31)='d';
*(FCNN_2L_W_FB1_22->name+32)='_';
*(FCNN_2L_W_FB1_22->name+33)='N';
*(FCNN_2L_W_FB1_22->name+34)='N';
*(FCNN_2L_W_FB1_22->name+35)='_';
*(FCNN_2L_W_FB1_22->name+36)='2';
*(FCNN_2L_W_FB1_22->name+37)='_';
*(FCNN_2L_W_FB1_22->name+38)='L';
*(FCNN_2L_W_FB1_22->name+39)='a';
*(FCNN_2L_W_FB1_22->name+40)='y';
*(FCNN_2L_W_FB1_22->name+41)='e';
*(FCNN_2L_W_FB1_22->name+42)='r';
*(FCNN_2L_W_FB1_22->name+43)='s';
*(FCNN_2L_W_FB1_22->name+44)='_';
*(FCNN_2L_W_FB1_22->name+45)='r';
*(FCNN_2L_W_FB1_22->name+46)='e';
*(FCNN_2L_W_FB1_22->name+47)='c';
*(FCNN_2L_W_FB1_22->name+48)='e';
*(FCNN_2L_W_FB1_22->name+49)='i';
*(FCNN_2L_W_FB1_22->name+50)='v';
*(FCNN_2L_W_FB1_22->name+51)='i';
*(FCNN_2L_W_FB1_22->name+52)='n';
*(FCNN_2L_W_FB1_22->name+53)='g';
*(FCNN_2L_W_FB1_22->name+54)='_';
*(FCNN_2L_W_FB1_22->name+55)='i';
*(FCNN_2L_W_FB1_22->name+56)='n';
*(FCNN_2L_W_FB1_22->name+57)='p';
*(FCNN_2L_W_FB1_22->name+58)='u';
*(FCNN_2L_W_FB1_22->name+59)='t';
*(FCNN_2L_W_FB1_22->name+60)='_';
*(FCNN_2L_W_FB1_22->name+61)='t';
*(FCNN_2L_W_FB1_22->name+62)='h';
*(FCNN_2L_W_FB1_22->name+63)='r';
*(FCNN_2L_W_FB1_22->name+64)='o';
*(FCNN_2L_W_FB1_22->name+65)='u';
*(FCNN_2L_W_FB1_22->name+66)='g';
*(FCNN_2L_W_FB1_22->name+67)='h';
*(FCNN_2L_W_FB1_22->name+68)='_';
*(FCNN_2L_W_FB1_22->name+69)='W';
*(FCNN_2L_W_FB1_22->name+70)='i';
*(FCNN_2L_W_FB1_22->name+71)='n';
*(FCNN_2L_W_FB1_22->name+72)='d';
*(FCNN_2L_W_FB1_22->name+73)='o';
*(FCNN_2L_W_FB1_22->name+74)='w';
*(FCNN_2L_W_FB1_22->name+75)='_';
*(FCNN_2L_W_FB1_22->name+76)='f';
*(FCNN_2L_W_FB1_22->name+77)='e';
*(FCNN_2L_W_FB1_22->name+78)='e';
*(FCNN_2L_W_FB1_22->name+79)='d';
*(FCNN_2L_W_FB1_22->name+80)='b';
*(FCNN_2L_W_FB1_22->name+81)='a';
*(FCNN_2L_W_FB1_22->name+82)='c';
*(FCNN_2L_W_FB1_22->name+83)='k';
*(FCNN_2L_W_FB1_22->name+84)='_';
*(FCNN_2L_W_FB1_22->name+85)='2';
*(FCNN_2L_W_FB1_22->name+86)='>';
*(FCNN_2L_W_FB1_22->name+87)='2';
*(FCNN_2L_W_FB1_22->name+88)=')';
*(FCNN_2L_W_FB1_22->name+89)=' ';
FCNN_2L_W_FB1_22->number_of_Levels=2;
FCNN_2L_W_FB1_22->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_22->prepare_input()) */
FCNN_2L_W_FB1_22->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_22->number_of_Levels);
*(FCNN_2L_W_FB1_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_22->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_22->recurrence=T;
FCNN_2L_W_FB1_22->number_of_recurrent_connected_layers=1;
FCNN_2L_W_FB1_22->source=MAI((long int)FCNN_2L_W_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22->source+0)=2;
FCNN_2L_W_FB1_22->destination=MAI((long int)FCNN_2L_W_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22->destination+0)=2;
FCNN_2L_W_FB1_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_22->create_neuron==0) exit_handling(76,1);
*(FCNN_2L_W_FB1_22->create_neuron+0)=create_FCNN_2L_FB1_22;
FCNN_2L_W_FB1_22->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_22->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_22->number_linear_output_functions=3;
FCNN_2L_W_FB1_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22->node_linear_output==0) exit_handling(76,2);
*(FCNN_2L_W_FB1_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_22->number_of_node_output_functions=4;
FCNN_2L_W_FB1_22->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22->node_output==0) exit_handling(76,3);
*(FCNN_2L_W_FB1_22->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22->node_output_derivation==0) exit_handling(76,4);
*(FCNN_2L_W_FB1_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_22->number_of_firing_functions=2;
FCNN_2L_W_FB1_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22->firing_neuron==0) exit_handling(76,5);
*(FCNN_2L_W_FB1_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FB1_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FB1_22->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_22->create_learning_algorithm==0) exit_handling(76,6);
*(FCNN_2L_W_FB1_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_22);
} /* ; */
/* setting up FCNN_2L_W_FB1_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_21;
FCNN_2L_W_FB1_21=MANTD((long int)1);
FCNN_2L_W_FB1_21->name=MAC((long int)90);
*(FCNN_2L_W_FB1_21->name+0)='F';
*(FCNN_2L_W_FB1_21->name+1)='C';
*(FCNN_2L_W_FB1_21->name+2)='N';
*(FCNN_2L_W_FB1_21->name+3)='N';
*(FCNN_2L_W_FB1_21->name+4)='_';
*(FCNN_2L_W_FB1_21->name+5)='2';
*(FCNN_2L_W_FB1_21->name+6)='L';
*(FCNN_2L_W_FB1_21->name+7)='_';
*(FCNN_2L_W_FB1_21->name+8)='W';
*(FCNN_2L_W_FB1_21->name+9)='_';
*(FCNN_2L_W_FB1_21->name+10)='F';
*(FCNN_2L_W_FB1_21->name+11)='B';
*(FCNN_2L_W_FB1_21->name+12)='1';
*(FCNN_2L_W_FB1_21->name+13)='_';
*(FCNN_2L_W_FB1_21->name+14)='2';
*(FCNN_2L_W_FB1_21->name+15)='1';
*(FCNN_2L_W_FB1_21->name+16)='(';
*(FCNN_2L_W_FB1_21->name+17)='F';
*(FCNN_2L_W_FB1_21->name+18)='u';
*(FCNN_2L_W_FB1_21->name+19)='l';
*(FCNN_2L_W_FB1_21->name+20)='l';
*(FCNN_2L_W_FB1_21->name+21)='y';
*(FCNN_2L_W_FB1_21->name+22)='_';
*(FCNN_2L_W_FB1_21->name+23)='C';
*(FCNN_2L_W_FB1_21->name+24)='o';
*(FCNN_2L_W_FB1_21->name+25)='n';
*(FCNN_2L_W_FB1_21->name+26)='n';
*(FCNN_2L_W_FB1_21->name+27)='e';
*(FCNN_2L_W_FB1_21->name+28)='c';
*(FCNN_2L_W_FB1_21->name+29)='t';
*(FCNN_2L_W_FB1_21->name+30)='e';
*(FCNN_2L_W_FB1_21->name+31)='d';
*(FCNN_2L_W_FB1_21->name+32)='_';
*(FCNN_2L_W_FB1_21->name+33)='N';
*(FCNN_2L_W_FB1_21->name+34)='N';
*(FCNN_2L_W_FB1_21->name+35)='_';
*(FCNN_2L_W_FB1_21->name+36)='2';
*(FCNN_2L_W_FB1_21->name+37)='_';
*(FCNN_2L_W_FB1_21->name+38)='L';
*(FCNN_2L_W_FB1_21->name+39)='a';
*(FCNN_2L_W_FB1_21->name+40)='y';
*(FCNN_2L_W_FB1_21->name+41)='e';
*(FCNN_2L_W_FB1_21->name+42)='r';
*(FCNN_2L_W_FB1_21->name+43)='s';
*(FCNN_2L_W_FB1_21->name+44)='_';
*(FCNN_2L_W_FB1_21->name+45)='r';
*(FCNN_2L_W_FB1_21->name+46)='e';
*(FCNN_2L_W_FB1_21->name+47)='c';
*(FCNN_2L_W_FB1_21->name+48)='e';
*(FCNN_2L_W_FB1_21->name+49)='i';
*(FCNN_2L_W_FB1_21->name+50)='v';
*(FCNN_2L_W_FB1_21->name+51)='i';
*(FCNN_2L_W_FB1_21->name+52)='n';
*(FCNN_2L_W_FB1_21->name+53)='g';
*(FCNN_2L_W_FB1_21->name+54)='_';
*(FCNN_2L_W_FB1_21->name+55)='i';
*(FCNN_2L_W_FB1_21->name+56)='n';
*(FCNN_2L_W_FB1_21->name+57)='p';
*(FCNN_2L_W_FB1_21->name+58)='u';
*(FCNN_2L_W_FB1_21->name+59)='t';
*(FCNN_2L_W_FB1_21->name+60)='_';
*(FCNN_2L_W_FB1_21->name+61)='t';
*(FCNN_2L_W_FB1_21->name+62)='h';
*(FCNN_2L_W_FB1_21->name+63)='r';
*(FCNN_2L_W_FB1_21->name+64)='o';
*(FCNN_2L_W_FB1_21->name+65)='u';
*(FCNN_2L_W_FB1_21->name+66)='g';
*(FCNN_2L_W_FB1_21->name+67)='h';
*(FCNN_2L_W_FB1_21->name+68)='_';
*(FCNN_2L_W_FB1_21->name+69)='W';
*(FCNN_2L_W_FB1_21->name+70)='i';
*(FCNN_2L_W_FB1_21->name+71)='n';
*(FCNN_2L_W_FB1_21->name+72)='d';
*(FCNN_2L_W_FB1_21->name+73)='o';
*(FCNN_2L_W_FB1_21->name+74)='w';
*(FCNN_2L_W_FB1_21->name+75)='_';
*(FCNN_2L_W_FB1_21->name+76)='f';
*(FCNN_2L_W_FB1_21->name+77)='e';
*(FCNN_2L_W_FB1_21->name+78)='e';
*(FCNN_2L_W_FB1_21->name+79)='d';
*(FCNN_2L_W_FB1_21->name+80)='b';
*(FCNN_2L_W_FB1_21->name+81)='a';
*(FCNN_2L_W_FB1_21->name+82)='c';
*(FCNN_2L_W_FB1_21->name+83)='k';
*(FCNN_2L_W_FB1_21->name+84)='_';
*(FCNN_2L_W_FB1_21->name+85)='2';
*(FCNN_2L_W_FB1_21->name+86)='>';
*(FCNN_2L_W_FB1_21->name+87)='1';
*(FCNN_2L_W_FB1_21->name+88)=')';
*(FCNN_2L_W_FB1_21->name+89)=' ';
FCNN_2L_W_FB1_21->number_of_Levels=2;
FCNN_2L_W_FB1_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_21->prepare_input()) as well from feedback */
FCNN_2L_W_FB1_21->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_21->number_of_Levels);
*(FCNN_2L_W_FB1_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_21->recurrence=T;
FCNN_2L_W_FB1_21->number_of_recurrent_connected_layers=1;
FCNN_2L_W_FB1_21->source=MAI((long int)FCNN_2L_W_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_21->source+0)=2;
FCNN_2L_W_FB1_21->destination=MAI((long int)FCNN_2L_W_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_21->destination+0)=1;
FCNN_2L_W_FB1_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_21->create_neuron==0) exit_handling(77,1);
*(FCNN_2L_W_FB1_21->create_neuron+0)=create_FCNN_2L_FB1_21;
FCNN_2L_W_FB1_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_21->number_linear_output_functions=3;
FCNN_2L_W_FB1_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21->node_linear_output==0) exit_handling(77,2);
*(FCNN_2L_W_FB1_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_21->number_of_node_output_functions=4;
FCNN_2L_W_FB1_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21->node_output==0) exit_handling(77,3);
*(FCNN_2L_W_FB1_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21->node_output_derivation==0) exit_handling(77,4);
*(FCNN_2L_W_FB1_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_21->number_of_firing_functions=2;
FCNN_2L_W_FB1_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21->firing_neuron==0) exit_handling(77,5);
*(FCNN_2L_W_FB1_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_W_FB1_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_W_FB1_21->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_21->create_learning_algorithm==0) exit_handling(77,6);
*(FCNN_2L_W_FB1_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_21);
} /* ; */
/* setting up FCNN_2L_W_FB1_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_22_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_22_11;
FCNN_2L_W_FB1_22_11=MANTD((long int)1);
FCNN_2L_W_FB1_22_11->name=MAC((long int)101);
*(FCNN_2L_W_FB1_22_11->name+0)='F';
*(FCNN_2L_W_FB1_22_11->name+1)='C';
*(FCNN_2L_W_FB1_22_11->name+2)='N';
*(FCNN_2L_W_FB1_22_11->name+3)='N';
*(FCNN_2L_W_FB1_22_11->name+4)='_';
*(FCNN_2L_W_FB1_22_11->name+5)='2';
*(FCNN_2L_W_FB1_22_11->name+6)='L';
*(FCNN_2L_W_FB1_22_11->name+7)='_';
*(FCNN_2L_W_FB1_22_11->name+8)='W';
*(FCNN_2L_W_FB1_22_11->name+9)='_';
*(FCNN_2L_W_FB1_22_11->name+10)='F';
*(FCNN_2L_W_FB1_22_11->name+11)='B';
*(FCNN_2L_W_FB1_22_11->name+12)='1';
*(FCNN_2L_W_FB1_22_11->name+13)='_';
*(FCNN_2L_W_FB1_22_11->name+14)='2';
*(FCNN_2L_W_FB1_22_11->name+15)='2';
*(FCNN_2L_W_FB1_22_11->name+16)='_';
*(FCNN_2L_W_FB1_22_11->name+17)='1';
*(FCNN_2L_W_FB1_22_11->name+18)='1';
*(FCNN_2L_W_FB1_22_11->name+19)='(';
*(FCNN_2L_W_FB1_22_11->name+20)='F';
*(FCNN_2L_W_FB1_22_11->name+21)='u';
*(FCNN_2L_W_FB1_22_11->name+22)='l';
*(FCNN_2L_W_FB1_22_11->name+23)='l';
*(FCNN_2L_W_FB1_22_11->name+24)='y';
*(FCNN_2L_W_FB1_22_11->name+25)='_';
*(FCNN_2L_W_FB1_22_11->name+26)='C';
*(FCNN_2L_W_FB1_22_11->name+27)='o';
*(FCNN_2L_W_FB1_22_11->name+28)='n';
*(FCNN_2L_W_FB1_22_11->name+29)='n';
*(FCNN_2L_W_FB1_22_11->name+30)='e';
*(FCNN_2L_W_FB1_22_11->name+31)='c';
*(FCNN_2L_W_FB1_22_11->name+32)='t';
*(FCNN_2L_W_FB1_22_11->name+33)='e';
*(FCNN_2L_W_FB1_22_11->name+34)='d';
*(FCNN_2L_W_FB1_22_11->name+35)='_';
*(FCNN_2L_W_FB1_22_11->name+36)='N';
*(FCNN_2L_W_FB1_22_11->name+37)='N';
*(FCNN_2L_W_FB1_22_11->name+38)='_';
*(FCNN_2L_W_FB1_22_11->name+39)='2';
*(FCNN_2L_W_FB1_22_11->name+40)='_';
*(FCNN_2L_W_FB1_22_11->name+41)='L';
*(FCNN_2L_W_FB1_22_11->name+42)='a';
*(FCNN_2L_W_FB1_22_11->name+43)='y';
*(FCNN_2L_W_FB1_22_11->name+44)='e';
*(FCNN_2L_W_FB1_22_11->name+45)='r';
*(FCNN_2L_W_FB1_22_11->name+46)='s';
*(FCNN_2L_W_FB1_22_11->name+47)='_';
*(FCNN_2L_W_FB1_22_11->name+48)='r';
*(FCNN_2L_W_FB1_22_11->name+49)='e';
*(FCNN_2L_W_FB1_22_11->name+50)='c';
*(FCNN_2L_W_FB1_22_11->name+51)='e';
*(FCNN_2L_W_FB1_22_11->name+52)='i';
*(FCNN_2L_W_FB1_22_11->name+53)='v';
*(FCNN_2L_W_FB1_22_11->name+54)='i';
*(FCNN_2L_W_FB1_22_11->name+55)='n';
*(FCNN_2L_W_FB1_22_11->name+56)='g';
*(FCNN_2L_W_FB1_22_11->name+57)='_';
*(FCNN_2L_W_FB1_22_11->name+58)='i';
*(FCNN_2L_W_FB1_22_11->name+59)='n';
*(FCNN_2L_W_FB1_22_11->name+60)='p';
*(FCNN_2L_W_FB1_22_11->name+61)='u';
*(FCNN_2L_W_FB1_22_11->name+62)='t';
*(FCNN_2L_W_FB1_22_11->name+63)='_';
*(FCNN_2L_W_FB1_22_11->name+64)='t';
*(FCNN_2L_W_FB1_22_11->name+65)='h';
*(FCNN_2L_W_FB1_22_11->name+66)='r';
*(FCNN_2L_W_FB1_22_11->name+67)='o';
*(FCNN_2L_W_FB1_22_11->name+68)='u';
*(FCNN_2L_W_FB1_22_11->name+69)='g';
*(FCNN_2L_W_FB1_22_11->name+70)='h';
*(FCNN_2L_W_FB1_22_11->name+71)='_';
*(FCNN_2L_W_FB1_22_11->name+72)='W';
*(FCNN_2L_W_FB1_22_11->name+73)='i';
*(FCNN_2L_W_FB1_22_11->name+74)='n';
*(FCNN_2L_W_FB1_22_11->name+75)='d';
*(FCNN_2L_W_FB1_22_11->name+76)='o';
*(FCNN_2L_W_FB1_22_11->name+77)='w';
*(FCNN_2L_W_FB1_22_11->name+78)='_';
*(FCNN_2L_W_FB1_22_11->name+79)='f';
*(FCNN_2L_W_FB1_22_11->name+80)='e';
*(FCNN_2L_W_FB1_22_11->name+81)='e';
*(FCNN_2L_W_FB1_22_11->name+82)='d';
*(FCNN_2L_W_FB1_22_11->name+83)='b';
*(FCNN_2L_W_FB1_22_11->name+84)='a';
*(FCNN_2L_W_FB1_22_11->name+85)='c';
*(FCNN_2L_W_FB1_22_11->name+86)='k';
*(FCNN_2L_W_FB1_22_11->name+87)='_';
*(FCNN_2L_W_FB1_22_11->name+88)='2';
*(FCNN_2L_W_FB1_22_11->name+89)='>';
*(FCNN_2L_W_FB1_22_11->name+90)='2';
*(FCNN_2L_W_FB1_22_11->name+91)='_';
*(FCNN_2L_W_FB1_22_11->name+92)='a';
*(FCNN_2L_W_FB1_22_11->name+93)='n';
*(FCNN_2L_W_FB1_22_11->name+94)='d';
*(FCNN_2L_W_FB1_22_11->name+95)='_';
*(FCNN_2L_W_FB1_22_11->name+96)='1';
*(FCNN_2L_W_FB1_22_11->name+97)='>';
*(FCNN_2L_W_FB1_22_11->name+98)='1';
*(FCNN_2L_W_FB1_22_11->name+99)=')';
*(FCNN_2L_W_FB1_22_11->name+100)=' ';
FCNN_2L_W_FB1_22_11->number_of_Levels=2;
FCNN_2L_W_FB1_22_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_22_11->prepare_input()) as well from feedback */
FCNN_2L_W_FB1_22_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_22_11->number_of_Levels);
*(FCNN_2L_W_FB1_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_22_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_22_11->recurrence=T;
FCNN_2L_W_FB1_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_FB1_22_11->source=MAI((long int)FCNN_2L_W_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22_11->source+0)=2;
*(FCNN_2L_W_FB1_22_11->source+1)=1;
FCNN_2L_W_FB1_22_11->destination=MAI((long int)FCNN_2L_W_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22_11->destination+0)=2;
*(FCNN_2L_W_FB1_22_11->destination+1)=1;
FCNN_2L_W_FB1_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_22_11->create_neuron==0) exit_handling(78,1);
*(FCNN_2L_W_FB1_22_11->create_neuron+0)=create_FCNN_2L_FB1_22_11;
FCNN_2L_W_FB1_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_22_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_22_11->number_linear_output_functions=3;
FCNN_2L_W_FB1_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_11->node_linear_output==0) exit_handling(78,2);
*(FCNN_2L_W_FB1_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_22_11->number_of_node_output_functions=4;
FCNN_2L_W_FB1_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_11->node_output==0) exit_handling(78,3);
*(FCNN_2L_W_FB1_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_11->node_output_derivation==0) exit_handling(78,4);
*(FCNN_2L_W_FB1_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_22_11->number_of_firing_functions=2;
FCNN_2L_W_FB1_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_11->firing_neuron==0) exit_handling(78,5);
*(FCNN_2L_W_FB1_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FB1_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FB1_22_11->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_22_11->create_learning_algorithm==0) exit_handling(78,6);
*(FCNN_2L_W_FB1_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_22_11);
} /* ; */
/* setting up FCNN_2L_W_FB1_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_21_11;
FCNN_2L_W_FB1_21_11=MANTD((long int)1);
FCNN_2L_W_FB1_21_11->name=MAC((long int)101);
*(FCNN_2L_W_FB1_21_11->name+0)='F';
*(FCNN_2L_W_FB1_21_11->name+1)='C';
*(FCNN_2L_W_FB1_21_11->name+2)='N';
*(FCNN_2L_W_FB1_21_11->name+3)='N';
*(FCNN_2L_W_FB1_21_11->name+4)='_';
*(FCNN_2L_W_FB1_21_11->name+5)='2';
*(FCNN_2L_W_FB1_21_11->name+6)='L';
*(FCNN_2L_W_FB1_21_11->name+7)='_';
*(FCNN_2L_W_FB1_21_11->name+8)='W';
*(FCNN_2L_W_FB1_21_11->name+9)='_';
*(FCNN_2L_W_FB1_21_11->name+10)='F';
*(FCNN_2L_W_FB1_21_11->name+11)='B';
*(FCNN_2L_W_FB1_21_11->name+12)='1';
*(FCNN_2L_W_FB1_21_11->name+13)='_';
*(FCNN_2L_W_FB1_21_11->name+14)='2';
*(FCNN_2L_W_FB1_21_11->name+15)='1';
*(FCNN_2L_W_FB1_21_11->name+16)='_';
*(FCNN_2L_W_FB1_21_11->name+17)='1';
*(FCNN_2L_W_FB1_21_11->name+18)='1';
*(FCNN_2L_W_FB1_21_11->name+19)='(';
*(FCNN_2L_W_FB1_21_11->name+20)='F';
*(FCNN_2L_W_FB1_21_11->name+21)='u';
*(FCNN_2L_W_FB1_21_11->name+22)='l';
*(FCNN_2L_W_FB1_21_11->name+23)='l';
*(FCNN_2L_W_FB1_21_11->name+24)='y';
*(FCNN_2L_W_FB1_21_11->name+25)='_';
*(FCNN_2L_W_FB1_21_11->name+26)='C';
*(FCNN_2L_W_FB1_21_11->name+27)='o';
*(FCNN_2L_W_FB1_21_11->name+28)='n';
*(FCNN_2L_W_FB1_21_11->name+29)='n';
*(FCNN_2L_W_FB1_21_11->name+30)='e';
*(FCNN_2L_W_FB1_21_11->name+31)='c';
*(FCNN_2L_W_FB1_21_11->name+32)='t';
*(FCNN_2L_W_FB1_21_11->name+33)='e';
*(FCNN_2L_W_FB1_21_11->name+34)='d';
*(FCNN_2L_W_FB1_21_11->name+35)='_';
*(FCNN_2L_W_FB1_21_11->name+36)='N';
*(FCNN_2L_W_FB1_21_11->name+37)='N';
*(FCNN_2L_W_FB1_21_11->name+38)='_';
*(FCNN_2L_W_FB1_21_11->name+39)='2';
*(FCNN_2L_W_FB1_21_11->name+40)='_';
*(FCNN_2L_W_FB1_21_11->name+41)='L';
*(FCNN_2L_W_FB1_21_11->name+42)='a';
*(FCNN_2L_W_FB1_21_11->name+43)='y';
*(FCNN_2L_W_FB1_21_11->name+44)='e';
*(FCNN_2L_W_FB1_21_11->name+45)='r';
*(FCNN_2L_W_FB1_21_11->name+46)='s';
*(FCNN_2L_W_FB1_21_11->name+47)='_';
*(FCNN_2L_W_FB1_21_11->name+48)='r';
*(FCNN_2L_W_FB1_21_11->name+49)='e';
*(FCNN_2L_W_FB1_21_11->name+50)='c';
*(FCNN_2L_W_FB1_21_11->name+51)='e';
*(FCNN_2L_W_FB1_21_11->name+52)='i';
*(FCNN_2L_W_FB1_21_11->name+53)='v';
*(FCNN_2L_W_FB1_21_11->name+54)='i';
*(FCNN_2L_W_FB1_21_11->name+55)='n';
*(FCNN_2L_W_FB1_21_11->name+56)='g';
*(FCNN_2L_W_FB1_21_11->name+57)='_';
*(FCNN_2L_W_FB1_21_11->name+58)='i';
*(FCNN_2L_W_FB1_21_11->name+59)='n';
*(FCNN_2L_W_FB1_21_11->name+60)='p';
*(FCNN_2L_W_FB1_21_11->name+61)='u';
*(FCNN_2L_W_FB1_21_11->name+62)='t';
*(FCNN_2L_W_FB1_21_11->name+63)='_';
*(FCNN_2L_W_FB1_21_11->name+64)='t';
*(FCNN_2L_W_FB1_21_11->name+65)='h';
*(FCNN_2L_W_FB1_21_11->name+66)='r';
*(FCNN_2L_W_FB1_21_11->name+67)='o';
*(FCNN_2L_W_FB1_21_11->name+68)='u';
*(FCNN_2L_W_FB1_21_11->name+69)='g';
*(FCNN_2L_W_FB1_21_11->name+70)='h';
*(FCNN_2L_W_FB1_21_11->name+71)='_';
*(FCNN_2L_W_FB1_21_11->name+72)='W';
*(FCNN_2L_W_FB1_21_11->name+73)='i';
*(FCNN_2L_W_FB1_21_11->name+74)='n';
*(FCNN_2L_W_FB1_21_11->name+75)='d';
*(FCNN_2L_W_FB1_21_11->name+76)='o';
*(FCNN_2L_W_FB1_21_11->name+77)='w';
*(FCNN_2L_W_FB1_21_11->name+78)='_';
*(FCNN_2L_W_FB1_21_11->name+79)='f';
*(FCNN_2L_W_FB1_21_11->name+80)='e';
*(FCNN_2L_W_FB1_21_11->name+81)='e';
*(FCNN_2L_W_FB1_21_11->name+82)='d';
*(FCNN_2L_W_FB1_21_11->name+83)='b';
*(FCNN_2L_W_FB1_21_11->name+84)='a';
*(FCNN_2L_W_FB1_21_11->name+85)='c';
*(FCNN_2L_W_FB1_21_11->name+86)='k';
*(FCNN_2L_W_FB1_21_11->name+87)='_';
*(FCNN_2L_W_FB1_21_11->name+88)='2';
*(FCNN_2L_W_FB1_21_11->name+89)='>';
*(FCNN_2L_W_FB1_21_11->name+90)='1';
*(FCNN_2L_W_FB1_21_11->name+91)='_';
*(FCNN_2L_W_FB1_21_11->name+92)='a';
*(FCNN_2L_W_FB1_21_11->name+93)='n';
*(FCNN_2L_W_FB1_21_11->name+94)='d';
*(FCNN_2L_W_FB1_21_11->name+95)='_';
*(FCNN_2L_W_FB1_21_11->name+96)='1';
*(FCNN_2L_W_FB1_21_11->name+97)='>';
*(FCNN_2L_W_FB1_21_11->name+98)='1';
*(FCNN_2L_W_FB1_21_11->name+99)=')';
*(FCNN_2L_W_FB1_21_11->name+100)=' ';
FCNN_2L_W_FB1_21_11->number_of_Levels=2;
FCNN_2L_W_FB1_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_21_11->prepare_input()) as well from feedback */
FCNN_2L_W_FB1_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_21_11->number_of_Levels);
*(FCNN_2L_W_FB1_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_21_11->recurrence=T;
FCNN_2L_W_FB1_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_FB1_21_11->source=MAI((long int)FCNN_2L_W_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_21_11->source+0)=2;
*(FCNN_2L_W_FB1_21_11->source+1)=1;
FCNN_2L_W_FB1_21_11->destination=MAI((long int)FCNN_2L_W_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_21_11->destination+0)=1;
*(FCNN_2L_W_FB1_21_11->destination+1)=1;
FCNN_2L_W_FB1_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_21_11->create_neuron==0) exit_handling(79,1);
*(FCNN_2L_W_FB1_21_11->create_neuron+0)=create_FCNN_2L_FB1_21_11;
FCNN_2L_W_FB1_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_21_11->number_linear_output_functions=3;
FCNN_2L_W_FB1_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21_11->node_linear_output==0) exit_handling(79,2);
*(FCNN_2L_W_FB1_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_21_11->number_of_node_output_functions=4;
FCNN_2L_W_FB1_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21_11->node_output==0) exit_handling(79,3);
*(FCNN_2L_W_FB1_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21_11->node_output_derivation==0) exit_handling(79,4);
*(FCNN_2L_W_FB1_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_21_11->number_of_firing_functions=2;
FCNN_2L_W_FB1_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_21_11->firing_neuron==0) exit_handling(79,5);
*(FCNN_2L_W_FB1_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FB1_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FB1_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_21_11->create_learning_algorithm==0) exit_handling(79,6);
*(FCNN_2L_W_FB1_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_21_11);
} /* ; */
/* setting up FCNN_2L_W_FB1_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_22_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_22_21;
FCNN_2L_W_FB1_22_21=MANTD((long int)1);
FCNN_2L_W_FB1_22_21->name=MAC((long int)101);
*(FCNN_2L_W_FB1_22_21->name+0)='F';
*(FCNN_2L_W_FB1_22_21->name+1)='C';
*(FCNN_2L_W_FB1_22_21->name+2)='N';
*(FCNN_2L_W_FB1_22_21->name+3)='N';
*(FCNN_2L_W_FB1_22_21->name+4)='_';
*(FCNN_2L_W_FB1_22_21->name+5)='2';
*(FCNN_2L_W_FB1_22_21->name+6)='L';
*(FCNN_2L_W_FB1_22_21->name+7)='_';
*(FCNN_2L_W_FB1_22_21->name+8)='W';
*(FCNN_2L_W_FB1_22_21->name+9)='_';
*(FCNN_2L_W_FB1_22_21->name+10)='F';
*(FCNN_2L_W_FB1_22_21->name+11)='B';
*(FCNN_2L_W_FB1_22_21->name+12)='1';
*(FCNN_2L_W_FB1_22_21->name+13)='_';
*(FCNN_2L_W_FB1_22_21->name+14)='2';
*(FCNN_2L_W_FB1_22_21->name+15)='2';
*(FCNN_2L_W_FB1_22_21->name+16)='_';
*(FCNN_2L_W_FB1_22_21->name+17)='2';
*(FCNN_2L_W_FB1_22_21->name+18)='1';
*(FCNN_2L_W_FB1_22_21->name+19)='(';
*(FCNN_2L_W_FB1_22_21->name+20)='F';
*(FCNN_2L_W_FB1_22_21->name+21)='u';
*(FCNN_2L_W_FB1_22_21->name+22)='l';
*(FCNN_2L_W_FB1_22_21->name+23)='l';
*(FCNN_2L_W_FB1_22_21->name+24)='y';
*(FCNN_2L_W_FB1_22_21->name+25)='_';
*(FCNN_2L_W_FB1_22_21->name+26)='C';
*(FCNN_2L_W_FB1_22_21->name+27)='o';
*(FCNN_2L_W_FB1_22_21->name+28)='n';
*(FCNN_2L_W_FB1_22_21->name+29)='n';
*(FCNN_2L_W_FB1_22_21->name+30)='e';
*(FCNN_2L_W_FB1_22_21->name+31)='c';
*(FCNN_2L_W_FB1_22_21->name+32)='t';
*(FCNN_2L_W_FB1_22_21->name+33)='e';
*(FCNN_2L_W_FB1_22_21->name+34)='d';
*(FCNN_2L_W_FB1_22_21->name+35)='_';
*(FCNN_2L_W_FB1_22_21->name+36)='N';
*(FCNN_2L_W_FB1_22_21->name+37)='N';
*(FCNN_2L_W_FB1_22_21->name+38)='_';
*(FCNN_2L_W_FB1_22_21->name+39)='2';
*(FCNN_2L_W_FB1_22_21->name+40)='_';
*(FCNN_2L_W_FB1_22_21->name+41)='L';
*(FCNN_2L_W_FB1_22_21->name+42)='a';
*(FCNN_2L_W_FB1_22_21->name+43)='y';
*(FCNN_2L_W_FB1_22_21->name+44)='e';
*(FCNN_2L_W_FB1_22_21->name+45)='r';
*(FCNN_2L_W_FB1_22_21->name+46)='s';
*(FCNN_2L_W_FB1_22_21->name+47)='_';
*(FCNN_2L_W_FB1_22_21->name+48)='r';
*(FCNN_2L_W_FB1_22_21->name+49)='e';
*(FCNN_2L_W_FB1_22_21->name+50)='c';
*(FCNN_2L_W_FB1_22_21->name+51)='e';
*(FCNN_2L_W_FB1_22_21->name+52)='i';
*(FCNN_2L_W_FB1_22_21->name+53)='v';
*(FCNN_2L_W_FB1_22_21->name+54)='i';
*(FCNN_2L_W_FB1_22_21->name+55)='n';
*(FCNN_2L_W_FB1_22_21->name+56)='g';
*(FCNN_2L_W_FB1_22_21->name+57)='_';
*(FCNN_2L_W_FB1_22_21->name+58)='i';
*(FCNN_2L_W_FB1_22_21->name+59)='n';
*(FCNN_2L_W_FB1_22_21->name+60)='p';
*(FCNN_2L_W_FB1_22_21->name+61)='u';
*(FCNN_2L_W_FB1_22_21->name+62)='t';
*(FCNN_2L_W_FB1_22_21->name+63)='_';
*(FCNN_2L_W_FB1_22_21->name+64)='t';
*(FCNN_2L_W_FB1_22_21->name+65)='h';
*(FCNN_2L_W_FB1_22_21->name+66)='r';
*(FCNN_2L_W_FB1_22_21->name+67)='o';
*(FCNN_2L_W_FB1_22_21->name+68)='u';
*(FCNN_2L_W_FB1_22_21->name+69)='g';
*(FCNN_2L_W_FB1_22_21->name+70)='h';
*(FCNN_2L_W_FB1_22_21->name+71)='_';
*(FCNN_2L_W_FB1_22_21->name+72)='W';
*(FCNN_2L_W_FB1_22_21->name+73)='i';
*(FCNN_2L_W_FB1_22_21->name+74)='n';
*(FCNN_2L_W_FB1_22_21->name+75)='d';
*(FCNN_2L_W_FB1_22_21->name+76)='o';
*(FCNN_2L_W_FB1_22_21->name+77)='w';
*(FCNN_2L_W_FB1_22_21->name+78)='_';
*(FCNN_2L_W_FB1_22_21->name+79)='f';
*(FCNN_2L_W_FB1_22_21->name+80)='e';
*(FCNN_2L_W_FB1_22_21->name+81)='e';
*(FCNN_2L_W_FB1_22_21->name+82)='d';
*(FCNN_2L_W_FB1_22_21->name+83)='b';
*(FCNN_2L_W_FB1_22_21->name+84)='a';
*(FCNN_2L_W_FB1_22_21->name+85)='c';
*(FCNN_2L_W_FB1_22_21->name+86)='k';
*(FCNN_2L_W_FB1_22_21->name+87)='_';
*(FCNN_2L_W_FB1_22_21->name+88)='2';
*(FCNN_2L_W_FB1_22_21->name+89)='>';
*(FCNN_2L_W_FB1_22_21->name+90)='2';
*(FCNN_2L_W_FB1_22_21->name+91)='_';
*(FCNN_2L_W_FB1_22_21->name+92)='a';
*(FCNN_2L_W_FB1_22_21->name+93)='n';
*(FCNN_2L_W_FB1_22_21->name+94)='d';
*(FCNN_2L_W_FB1_22_21->name+95)='_';
*(FCNN_2L_W_FB1_22_21->name+96)='2';
*(FCNN_2L_W_FB1_22_21->name+97)='>';
*(FCNN_2L_W_FB1_22_21->name+98)='1';
*(FCNN_2L_W_FB1_22_21->name+99)=')';
*(FCNN_2L_W_FB1_22_21->name+100)=' ';
FCNN_2L_W_FB1_22_21->number_of_Levels=2;
FCNN_2L_W_FB1_22_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_22_21->prepare_input()) as well from feedback */
FCNN_2L_W_FB1_22_21->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_22_21->number_of_Levels);
*(FCNN_2L_W_FB1_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_22_21->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_22_21->recurrence=T;
FCNN_2L_W_FB1_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_W_FB1_22_21->source=MAI((long int)FCNN_2L_W_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22_21->source+0)=2;
*(FCNN_2L_W_FB1_22_21->source+1)=2;
FCNN_2L_W_FB1_22_21->destination=MAI((long int)FCNN_2L_W_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22_21->destination+0)=2;
*(FCNN_2L_W_FB1_22_21->destination+1)=1;
FCNN_2L_W_FB1_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_22_21->create_neuron==0) exit_handling(80,1);
*(FCNN_2L_W_FB1_22_21->create_neuron+0)=create_FCNN_2L_FB1_22_21;
FCNN_2L_W_FB1_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_22_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_22_21->number_linear_output_functions=3;
FCNN_2L_W_FB1_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21->node_linear_output==0) exit_handling(80,2);
*(FCNN_2L_W_FB1_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_22_21->number_of_node_output_functions=4;
FCNN_2L_W_FB1_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21->node_output==0) exit_handling(80,3);
*(FCNN_2L_W_FB1_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21->node_output_derivation==0) exit_handling(80,4);
*(FCNN_2L_W_FB1_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_22_21->number_of_firing_functions=2;
FCNN_2L_W_FB1_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21->firing_neuron==0) exit_handling(80,5);
*(FCNN_2L_W_FB1_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FB1_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FB1_22_21->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_22_21->create_learning_algorithm==0) exit_handling(80,6);
*(FCNN_2L_W_FB1_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_22_21);
} /* ; */
/* setting up FCNN_2L_W_FB1_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_FB1_22_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radius, and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_FB1_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_FB1_22_21_11;
FCNN_2L_W_FB1_22_21_11=MANTD((long int)1);
FCNN_2L_W_FB1_22_21_11->name=MAC((long int)112);
*(FCNN_2L_W_FB1_22_21_11->name+0)='F';
*(FCNN_2L_W_FB1_22_21_11->name+1)='C';
*(FCNN_2L_W_FB1_22_21_11->name+2)='N';
*(FCNN_2L_W_FB1_22_21_11->name+3)='N';
*(FCNN_2L_W_FB1_22_21_11->name+4)='_';
*(FCNN_2L_W_FB1_22_21_11->name+5)='2';
*(FCNN_2L_W_FB1_22_21_11->name+6)='L';
*(FCNN_2L_W_FB1_22_21_11->name+7)='_';
*(FCNN_2L_W_FB1_22_21_11->name+8)='W';
*(FCNN_2L_W_FB1_22_21_11->name+9)='_';
*(FCNN_2L_W_FB1_22_21_11->name+10)='F';
*(FCNN_2L_W_FB1_22_21_11->name+11)='B';
*(FCNN_2L_W_FB1_22_21_11->name+12)='1';
*(FCNN_2L_W_FB1_22_21_11->name+13)='_';
*(FCNN_2L_W_FB1_22_21_11->name+14)='2';
*(FCNN_2L_W_FB1_22_21_11->name+15)='2';
*(FCNN_2L_W_FB1_22_21_11->name+16)='_';
*(FCNN_2L_W_FB1_22_21_11->name+17)='2';
*(FCNN_2L_W_FB1_22_21_11->name+18)='1';
*(FCNN_2L_W_FB1_22_21_11->name+19)='_';
*(FCNN_2L_W_FB1_22_21_11->name+20)='1';
*(FCNN_2L_W_FB1_22_21_11->name+21)='1';
*(FCNN_2L_W_FB1_22_21_11->name+22)='(';
*(FCNN_2L_W_FB1_22_21_11->name+23)='F';
*(FCNN_2L_W_FB1_22_21_11->name+24)='u';
*(FCNN_2L_W_FB1_22_21_11->name+25)='l';
*(FCNN_2L_W_FB1_22_21_11->name+26)='l';
*(FCNN_2L_W_FB1_22_21_11->name+27)='y';
*(FCNN_2L_W_FB1_22_21_11->name+28)='_';
*(FCNN_2L_W_FB1_22_21_11->name+29)='C';
*(FCNN_2L_W_FB1_22_21_11->name+30)='o';
*(FCNN_2L_W_FB1_22_21_11->name+31)='n';
*(FCNN_2L_W_FB1_22_21_11->name+32)='n';
*(FCNN_2L_W_FB1_22_21_11->name+33)='e';
*(FCNN_2L_W_FB1_22_21_11->name+34)='c';
*(FCNN_2L_W_FB1_22_21_11->name+35)='t';
*(FCNN_2L_W_FB1_22_21_11->name+36)='e';
*(FCNN_2L_W_FB1_22_21_11->name+37)='d';
*(FCNN_2L_W_FB1_22_21_11->name+38)='_';
*(FCNN_2L_W_FB1_22_21_11->name+39)='N';
*(FCNN_2L_W_FB1_22_21_11->name+40)='N';
*(FCNN_2L_W_FB1_22_21_11->name+41)='_';
*(FCNN_2L_W_FB1_22_21_11->name+42)='2';
*(FCNN_2L_W_FB1_22_21_11->name+43)='_';
*(FCNN_2L_W_FB1_22_21_11->name+44)='L';
*(FCNN_2L_W_FB1_22_21_11->name+45)='a';
*(FCNN_2L_W_FB1_22_21_11->name+46)='y';
*(FCNN_2L_W_FB1_22_21_11->name+47)='e';
*(FCNN_2L_W_FB1_22_21_11->name+48)='r';
*(FCNN_2L_W_FB1_22_21_11->name+49)='s';
*(FCNN_2L_W_FB1_22_21_11->name+50)='_';
*(FCNN_2L_W_FB1_22_21_11->name+51)='r';
*(FCNN_2L_W_FB1_22_21_11->name+52)='e';
*(FCNN_2L_W_FB1_22_21_11->name+53)='c';
*(FCNN_2L_W_FB1_22_21_11->name+54)='e';
*(FCNN_2L_W_FB1_22_21_11->name+55)='i';
*(FCNN_2L_W_FB1_22_21_11->name+56)='v';
*(FCNN_2L_W_FB1_22_21_11->name+57)='i';
*(FCNN_2L_W_FB1_22_21_11->name+58)='n';
*(FCNN_2L_W_FB1_22_21_11->name+59)='g';
*(FCNN_2L_W_FB1_22_21_11->name+60)='_';
*(FCNN_2L_W_FB1_22_21_11->name+61)='i';
*(FCNN_2L_W_FB1_22_21_11->name+62)='n';
*(FCNN_2L_W_FB1_22_21_11->name+63)='p';
*(FCNN_2L_W_FB1_22_21_11->name+64)='u';
*(FCNN_2L_W_FB1_22_21_11->name+65)='t';
*(FCNN_2L_W_FB1_22_21_11->name+66)='_';
*(FCNN_2L_W_FB1_22_21_11->name+67)='t';
*(FCNN_2L_W_FB1_22_21_11->name+68)='h';
*(FCNN_2L_W_FB1_22_21_11->name+69)='r';
*(FCNN_2L_W_FB1_22_21_11->name+70)='o';
*(FCNN_2L_W_FB1_22_21_11->name+71)='u';
*(FCNN_2L_W_FB1_22_21_11->name+72)='g';
*(FCNN_2L_W_FB1_22_21_11->name+73)='h';
*(FCNN_2L_W_FB1_22_21_11->name+74)='_';
*(FCNN_2L_W_FB1_22_21_11->name+75)='W';
*(FCNN_2L_W_FB1_22_21_11->name+76)='i';
*(FCNN_2L_W_FB1_22_21_11->name+77)='n';
*(FCNN_2L_W_FB1_22_21_11->name+78)='d';
*(FCNN_2L_W_FB1_22_21_11->name+79)='o';
*(FCNN_2L_W_FB1_22_21_11->name+80)='w';
*(FCNN_2L_W_FB1_22_21_11->name+81)='_';
*(FCNN_2L_W_FB1_22_21_11->name+82)='f';
*(FCNN_2L_W_FB1_22_21_11->name+83)='e';
*(FCNN_2L_W_FB1_22_21_11->name+84)='e';
*(FCNN_2L_W_FB1_22_21_11->name+85)='d';
*(FCNN_2L_W_FB1_22_21_11->name+86)='b';
*(FCNN_2L_W_FB1_22_21_11->name+87)='a';
*(FCNN_2L_W_FB1_22_21_11->name+88)='c';
*(FCNN_2L_W_FB1_22_21_11->name+89)='k';
*(FCNN_2L_W_FB1_22_21_11->name+90)='_';
*(FCNN_2L_W_FB1_22_21_11->name+91)='2';
*(FCNN_2L_W_FB1_22_21_11->name+92)='>';
*(FCNN_2L_W_FB1_22_21_11->name+93)='2';
*(FCNN_2L_W_FB1_22_21_11->name+94)='_';
*(FCNN_2L_W_FB1_22_21_11->name+95)='a';
*(FCNN_2L_W_FB1_22_21_11->name+96)='n';
*(FCNN_2L_W_FB1_22_21_11->name+97)='d';
*(FCNN_2L_W_FB1_22_21_11->name+98)='_';
*(FCNN_2L_W_FB1_22_21_11->name+99)='2';
*(FCNN_2L_W_FB1_22_21_11->name+100)='>';
*(FCNN_2L_W_FB1_22_21_11->name+101)='1';
*(FCNN_2L_W_FB1_22_21_11->name+102)='_';
*(FCNN_2L_W_FB1_22_21_11->name+103)='a';
*(FCNN_2L_W_FB1_22_21_11->name+104)='n';
*(FCNN_2L_W_FB1_22_21_11->name+105)='d';
*(FCNN_2L_W_FB1_22_21_11->name+106)='_';
*(FCNN_2L_W_FB1_22_21_11->name+107)='1';
*(FCNN_2L_W_FB1_22_21_11->name+108)='>';
*(FCNN_2L_W_FB1_22_21_11->name+109)='1';
*(FCNN_2L_W_FB1_22_21_11->name+110)=')';
*(FCNN_2L_W_FB1_22_21_11->name+111)=' ';
FCNN_2L_W_FB1_22_21_11->number_of_Levels=2;
FCNN_2L_W_FB1_22_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_FB1_22_21_11->prepare_input()) as well from feedback */
FCNN_2L_W_FB1_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_FB1_22_21_11->number_of_Levels);
*(FCNN_2L_W_FB1_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_FB1_22_21_11->nodes_per_Level+1)=0; /* means there is the same number of nodes in the 2nd Level as there are inputs */
FCNN_2L_W_FB1_22_21_11->recurrence=T;
FCNN_2L_W_FB1_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_W_FB1_22_21_11->source=MAI((long int)FCNN_2L_W_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22_21_11->source+0)=2;
*(FCNN_2L_W_FB1_22_21_11->source+1)=2;
*(FCNN_2L_W_FB1_22_21_11->source+2)=1;
FCNN_2L_W_FB1_22_21_11->destination=MAI((long int)FCNN_2L_W_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_FB1_22_21_11->destination+0)=2;
*(FCNN_2L_W_FB1_22_21_11->destination+1)=1;
*(FCNN_2L_W_FB1_22_21_11->destination+2)=1;
FCNN_2L_W_FB1_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_FB1_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_FB1_22_21_11->create_neuron==0) exit_handling(81,1);
*(FCNN_2L_W_FB1_22_21_11->create_neuron+0)=create_FCNN_2L_FB1_22_21_11;
FCNN_2L_W_FB1_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_FB1_22_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_FB1_22_21_11->number_linear_output_functions=3;
FCNN_2L_W_FB1_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21_11->node_linear_output==0) exit_handling(81,2);
*(FCNN_2L_W_FB1_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_FB1_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_FB1_22_21_11->number_of_node_output_functions=4;
FCNN_2L_W_FB1_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21_11->node_output==0) exit_handling(81,3);
*(FCNN_2L_W_FB1_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_FB1_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_FB1_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_FB1_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_FB1_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21_11->node_output_derivation==0) exit_handling(81,4);
*(FCNN_2L_W_FB1_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_FB1_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_FB1_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_FB1_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_FB1_22_21_11->number_of_firing_functions=2;
FCNN_2L_W_FB1_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_FB1_22_21_11->firing_neuron==0) exit_handling(81,5);
*(FCNN_2L_W_FB1_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_FB1_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_FB1_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_FB1_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_FB1_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_FB1_22_21_11->create_learning_algorithm==0) exit_handling(81,6);
*(FCNN_2L_W_FB1_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_FB1_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_FB1_22_21_11);
} /* ; */
/* setting up FCNN_2L_1out_FB1_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_11;
FCNN_2L_1out_FB1_11=MANTD((long int)1);
FCNN_2L_1out_FB1_11->name=MAC((long int)71);
*(FCNN_2L_1out_FB1_11->name+0)='F';
*(FCNN_2L_1out_FB1_11->name+1)='C';
*(FCNN_2L_1out_FB1_11->name+2)='N';
*(FCNN_2L_1out_FB1_11->name+3)='N';
*(FCNN_2L_1out_FB1_11->name+4)='_';
*(FCNN_2L_1out_FB1_11->name+5)='2';
*(FCNN_2L_1out_FB1_11->name+6)='L';
*(FCNN_2L_1out_FB1_11->name+7)='_';
*(FCNN_2L_1out_FB1_11->name+8)='1';
*(FCNN_2L_1out_FB1_11->name+9)='o';
*(FCNN_2L_1out_FB1_11->name+10)='u';
*(FCNN_2L_1out_FB1_11->name+11)='t';
*(FCNN_2L_1out_FB1_11->name+12)='_';
*(FCNN_2L_1out_FB1_11->name+13)='F';
*(FCNN_2L_1out_FB1_11->name+14)='B';
*(FCNN_2L_1out_FB1_11->name+15)='1';
*(FCNN_2L_1out_FB1_11->name+16)='_';
*(FCNN_2L_1out_FB1_11->name+17)='1';
*(FCNN_2L_1out_FB1_11->name+18)='1';
*(FCNN_2L_1out_FB1_11->name+19)='(';
*(FCNN_2L_1out_FB1_11->name+20)='F';
*(FCNN_2L_1out_FB1_11->name+21)='u';
*(FCNN_2L_1out_FB1_11->name+22)='l';
*(FCNN_2L_1out_FB1_11->name+23)='l';
*(FCNN_2L_1out_FB1_11->name+24)='y';
*(FCNN_2L_1out_FB1_11->name+25)='_';
*(FCNN_2L_1out_FB1_11->name+26)='C';
*(FCNN_2L_1out_FB1_11->name+27)='o';
*(FCNN_2L_1out_FB1_11->name+28)='n';
*(FCNN_2L_1out_FB1_11->name+29)='n';
*(FCNN_2L_1out_FB1_11->name+30)='e';
*(FCNN_2L_1out_FB1_11->name+31)='c';
*(FCNN_2L_1out_FB1_11->name+32)='t';
*(FCNN_2L_1out_FB1_11->name+33)='e';
*(FCNN_2L_1out_FB1_11->name+34)='d';
*(FCNN_2L_1out_FB1_11->name+35)='_';
*(FCNN_2L_1out_FB1_11->name+36)='N';
*(FCNN_2L_1out_FB1_11->name+37)='N';
*(FCNN_2L_1out_FB1_11->name+38)='_';
*(FCNN_2L_1out_FB1_11->name+39)='2';
*(FCNN_2L_1out_FB1_11->name+40)='_';
*(FCNN_2L_1out_FB1_11->name+41)='L';
*(FCNN_2L_1out_FB1_11->name+42)='a';
*(FCNN_2L_1out_FB1_11->name+43)='y';
*(FCNN_2L_1out_FB1_11->name+44)='e';
*(FCNN_2L_1out_FB1_11->name+45)='r';
*(FCNN_2L_1out_FB1_11->name+46)='s';
*(FCNN_2L_1out_FB1_11->name+47)='_';
*(FCNN_2L_1out_FB1_11->name+48)='1';
*(FCNN_2L_1out_FB1_11->name+49)='_';
*(FCNN_2L_1out_FB1_11->name+50)='o';
*(FCNN_2L_1out_FB1_11->name+51)='u';
*(FCNN_2L_1out_FB1_11->name+52)='t';
*(FCNN_2L_1out_FB1_11->name+53)='p';
*(FCNN_2L_1out_FB1_11->name+54)='u';
*(FCNN_2L_1out_FB1_11->name+55)='t';
*(FCNN_2L_1out_FB1_11->name+56)='_';
*(FCNN_2L_1out_FB1_11->name+57)='f';
*(FCNN_2L_1out_FB1_11->name+58)='e';
*(FCNN_2L_1out_FB1_11->name+59)='e';
*(FCNN_2L_1out_FB1_11->name+60)='d';
*(FCNN_2L_1out_FB1_11->name+61)='b';
*(FCNN_2L_1out_FB1_11->name+62)='a';
*(FCNN_2L_1out_FB1_11->name+63)='c';
*(FCNN_2L_1out_FB1_11->name+64)='k';
*(FCNN_2L_1out_FB1_11->name+65)='_';
*(FCNN_2L_1out_FB1_11->name+66)='1';
*(FCNN_2L_1out_FB1_11->name+67)='>';
*(FCNN_2L_1out_FB1_11->name+68)='1';
*(FCNN_2L_1out_FB1_11->name+69)=')';
*(FCNN_2L_1out_FB1_11->name+70)=' ';
FCNN_2L_1out_FB1_11->number_of_Levels=2;
FCNN_2L_1out_FB1_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FB1_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_11->number_of_Levels);
*(FCNN_2L_1out_FB1_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_11->recurrence=T;
FCNN_2L_1out_FB1_11->number_of_recurrent_connected_layers=1;
FCNN_2L_1out_FB1_11->source=MAI((long int)FCNN_2L_1out_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_11->source+0)=1;
FCNN_2L_1out_FB1_11->destination=MAI((long int)FCNN_2L_1out_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_11->destination+0)=1;
FCNN_2L_1out_FB1_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_11->create_neuron==0) exit_handling(82,1);
*(FCNN_2L_1out_FB1_11->create_neuron+0)=create_FCNN_2L_1out_FB1_11;
FCNN_2L_1out_FB1_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_11->prepare_input=0;
FCNN_2L_1out_FB1_11->number_linear_output_functions=3;
FCNN_2L_1out_FB1_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_11->node_linear_output==0) exit_handling(82,2);
*(FCNN_2L_1out_FB1_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_11->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_11->node_output==0) exit_handling(82,3);
*(FCNN_2L_1out_FB1_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_11->node_output_derivation==0) exit_handling(82,4);
*(FCNN_2L_1out_FB1_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_11->number_of_firing_functions=2;
FCNN_2L_1out_FB1_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_11->firing_neuron==0) exit_handling(82,5);
*(FCNN_2L_1out_FB1_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FB1_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FB1_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_11->create_learning_algorithm==0) exit_handling(82,6);
*(FCNN_2L_1out_FB1_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_11);
} /* ; */
/* setting up FCNN_2L_1out_FB1_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_22 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_22;
FCNN_2L_1out_FB1_22=MANTD((long int)1);
FCNN_2L_1out_FB1_22->name=MAC((long int)71);
*(FCNN_2L_1out_FB1_22->name+0)='F';
*(FCNN_2L_1out_FB1_22->name+1)='C';
*(FCNN_2L_1out_FB1_22->name+2)='N';
*(FCNN_2L_1out_FB1_22->name+3)='N';
*(FCNN_2L_1out_FB1_22->name+4)='_';
*(FCNN_2L_1out_FB1_22->name+5)='2';
*(FCNN_2L_1out_FB1_22->name+6)='L';
*(FCNN_2L_1out_FB1_22->name+7)='_';
*(FCNN_2L_1out_FB1_22->name+8)='1';
*(FCNN_2L_1out_FB1_22->name+9)='o';
*(FCNN_2L_1out_FB1_22->name+10)='u';
*(FCNN_2L_1out_FB1_22->name+11)='t';
*(FCNN_2L_1out_FB1_22->name+12)='_';
*(FCNN_2L_1out_FB1_22->name+13)='F';
*(FCNN_2L_1out_FB1_22->name+14)='B';
*(FCNN_2L_1out_FB1_22->name+15)='1';
*(FCNN_2L_1out_FB1_22->name+16)='_';
*(FCNN_2L_1out_FB1_22->name+17)='2';
*(FCNN_2L_1out_FB1_22->name+18)='2';
*(FCNN_2L_1out_FB1_22->name+19)='(';
*(FCNN_2L_1out_FB1_22->name+20)='F';
*(FCNN_2L_1out_FB1_22->name+21)='u';
*(FCNN_2L_1out_FB1_22->name+22)='l';
*(FCNN_2L_1out_FB1_22->name+23)='l';
*(FCNN_2L_1out_FB1_22->name+24)='y';
*(FCNN_2L_1out_FB1_22->name+25)='_';
*(FCNN_2L_1out_FB1_22->name+26)='C';
*(FCNN_2L_1out_FB1_22->name+27)='o';
*(FCNN_2L_1out_FB1_22->name+28)='n';
*(FCNN_2L_1out_FB1_22->name+29)='n';
*(FCNN_2L_1out_FB1_22->name+30)='e';
*(FCNN_2L_1out_FB1_22->name+31)='c';
*(FCNN_2L_1out_FB1_22->name+32)='t';
*(FCNN_2L_1out_FB1_22->name+33)='e';
*(FCNN_2L_1out_FB1_22->name+34)='d';
*(FCNN_2L_1out_FB1_22->name+35)='_';
*(FCNN_2L_1out_FB1_22->name+36)='N';
*(FCNN_2L_1out_FB1_22->name+37)='N';
*(FCNN_2L_1out_FB1_22->name+38)='_';
*(FCNN_2L_1out_FB1_22->name+39)='2';
*(FCNN_2L_1out_FB1_22->name+40)='_';
*(FCNN_2L_1out_FB1_22->name+41)='L';
*(FCNN_2L_1out_FB1_22->name+42)='a';
*(FCNN_2L_1out_FB1_22->name+43)='y';
*(FCNN_2L_1out_FB1_22->name+44)='e';
*(FCNN_2L_1out_FB1_22->name+45)='r';
*(FCNN_2L_1out_FB1_22->name+46)='s';
*(FCNN_2L_1out_FB1_22->name+47)='_';
*(FCNN_2L_1out_FB1_22->name+48)='1';
*(FCNN_2L_1out_FB1_22->name+49)='_';
*(FCNN_2L_1out_FB1_22->name+50)='o';
*(FCNN_2L_1out_FB1_22->name+51)='u';
*(FCNN_2L_1out_FB1_22->name+52)='t';
*(FCNN_2L_1out_FB1_22->name+53)='p';
*(FCNN_2L_1out_FB1_22->name+54)='u';
*(FCNN_2L_1out_FB1_22->name+55)='t';
*(FCNN_2L_1out_FB1_22->name+56)='_';
*(FCNN_2L_1out_FB1_22->name+57)='f';
*(FCNN_2L_1out_FB1_22->name+58)='e';
*(FCNN_2L_1out_FB1_22->name+59)='e';
*(FCNN_2L_1out_FB1_22->name+60)='d';
*(FCNN_2L_1out_FB1_22->name+61)='b';
*(FCNN_2L_1out_FB1_22->name+62)='a';
*(FCNN_2L_1out_FB1_22->name+63)='c';
*(FCNN_2L_1out_FB1_22->name+64)='k';
*(FCNN_2L_1out_FB1_22->name+65)='_';
*(FCNN_2L_1out_FB1_22->name+66)='2';
*(FCNN_2L_1out_FB1_22->name+67)='>';
*(FCNN_2L_1out_FB1_22->name+68)='2';
*(FCNN_2L_1out_FB1_22->name+69)=')';
*(FCNN_2L_1out_FB1_22->name+70)=' ';
FCNN_2L_1out_FB1_22->number_of_Levels=2;
FCNN_2L_1out_FB1_22->inputs_per_first_Level_node=2; /* means all inputs are associated with all 1st Level nodes */
FCNN_2L_1out_FB1_22->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_22->number_of_Levels);
*(FCNN_2L_1out_FB1_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_22->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_22->recurrence=T;
FCNN_2L_1out_FB1_22->number_of_recurrent_connected_layers=1;
FCNN_2L_1out_FB1_22->source=MAI((long int)FCNN_2L_1out_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22->source+0)=2;
FCNN_2L_1out_FB1_22->destination=MAI((long int)FCNN_2L_1out_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22->destination+0)=2;
FCNN_2L_1out_FB1_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_22->create_neuron==0) exit_handling(83,1);
*(FCNN_2L_1out_FB1_22->create_neuron+0)=create_FCNN_2L_1out_FB1_22;
FCNN_2L_1out_FB1_22->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_22->prepare_input=0;
FCNN_2L_1out_FB1_22->number_linear_output_functions=3;
FCNN_2L_1out_FB1_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22->node_linear_output==0) exit_handling(83,2);
*(FCNN_2L_1out_FB1_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_22->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_22->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22->node_output==0) exit_handling(83,3);
*(FCNN_2L_1out_FB1_22->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22->node_output_derivation==0) exit_handling(83,4);
*(FCNN_2L_1out_FB1_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_22->number_of_firing_functions=2;
FCNN_2L_1out_FB1_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22->firing_neuron==0) exit_handling(83,5);
*(FCNN_2L_1out_FB1_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FB1_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FB1_22->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_22->create_learning_algorithm==0) exit_handling(83,6);
*(FCNN_2L_1out_FB1_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_22);
} /* ; */
/* setting up FCNN_2L_1out_FB1_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_21 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto the 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_21;
FCNN_2L_1out_FB1_21=MANTD((long int)1);
FCNN_2L_1out_FB1_21->name=MAC((long int)71);
*(FCNN_2L_1out_FB1_21->name+0)='F';
*(FCNN_2L_1out_FB1_21->name+1)='C';
*(FCNN_2L_1out_FB1_21->name+2)='N';
*(FCNN_2L_1out_FB1_21->name+3)='N';
*(FCNN_2L_1out_FB1_21->name+4)='_';
*(FCNN_2L_1out_FB1_21->name+5)='2';
*(FCNN_2L_1out_FB1_21->name+6)='L';
*(FCNN_2L_1out_FB1_21->name+7)='_';
*(FCNN_2L_1out_FB1_21->name+8)='1';
*(FCNN_2L_1out_FB1_21->name+9)='o';
*(FCNN_2L_1out_FB1_21->name+10)='u';
*(FCNN_2L_1out_FB1_21->name+11)='t';
*(FCNN_2L_1out_FB1_21->name+12)='_';
*(FCNN_2L_1out_FB1_21->name+13)='F';
*(FCNN_2L_1out_FB1_21->name+14)='B';
*(FCNN_2L_1out_FB1_21->name+15)='1';
*(FCNN_2L_1out_FB1_21->name+16)='_';
*(FCNN_2L_1out_FB1_21->name+17)='2';
*(FCNN_2L_1out_FB1_21->name+18)='1';
*(FCNN_2L_1out_FB1_21->name+19)='(';
*(FCNN_2L_1out_FB1_21->name+20)='F';
*(FCNN_2L_1out_FB1_21->name+21)='u';
*(FCNN_2L_1out_FB1_21->name+22)='l';
*(FCNN_2L_1out_FB1_21->name+23)='l';
*(FCNN_2L_1out_FB1_21->name+24)='y';
*(FCNN_2L_1out_FB1_21->name+25)='_';
*(FCNN_2L_1out_FB1_21->name+26)='C';
*(FCNN_2L_1out_FB1_21->name+27)='o';
*(FCNN_2L_1out_FB1_21->name+28)='n';
*(FCNN_2L_1out_FB1_21->name+29)='n';
*(FCNN_2L_1out_FB1_21->name+30)='e';
*(FCNN_2L_1out_FB1_21->name+31)='c';
*(FCNN_2L_1out_FB1_21->name+32)='t';
*(FCNN_2L_1out_FB1_21->name+33)='e';
*(FCNN_2L_1out_FB1_21->name+34)='d';
*(FCNN_2L_1out_FB1_21->name+35)='_';
*(FCNN_2L_1out_FB1_21->name+36)='N';
*(FCNN_2L_1out_FB1_21->name+37)='N';
*(FCNN_2L_1out_FB1_21->name+38)='_';
*(FCNN_2L_1out_FB1_21->name+39)='2';
*(FCNN_2L_1out_FB1_21->name+40)='_';
*(FCNN_2L_1out_FB1_21->name+41)='L';
*(FCNN_2L_1out_FB1_21->name+42)='a';
*(FCNN_2L_1out_FB1_21->name+43)='y';
*(FCNN_2L_1out_FB1_21->name+44)='e';
*(FCNN_2L_1out_FB1_21->name+45)='r';
*(FCNN_2L_1out_FB1_21->name+46)='s';
*(FCNN_2L_1out_FB1_21->name+47)='_';
*(FCNN_2L_1out_FB1_21->name+48)='1';
*(FCNN_2L_1out_FB1_21->name+49)='_';
*(FCNN_2L_1out_FB1_21->name+50)='o';
*(FCNN_2L_1out_FB1_21->name+51)='u';
*(FCNN_2L_1out_FB1_21->name+52)='t';
*(FCNN_2L_1out_FB1_21->name+53)='p';
*(FCNN_2L_1out_FB1_21->name+54)='u';
*(FCNN_2L_1out_FB1_21->name+55)='t';
*(FCNN_2L_1out_FB1_21->name+56)='_';
*(FCNN_2L_1out_FB1_21->name+57)='f';
*(FCNN_2L_1out_FB1_21->name+58)='e';
*(FCNN_2L_1out_FB1_21->name+59)='e';
*(FCNN_2L_1out_FB1_21->name+60)='d';
*(FCNN_2L_1out_FB1_21->name+61)='b';
*(FCNN_2L_1out_FB1_21->name+62)='a';
*(FCNN_2L_1out_FB1_21->name+63)='c';
*(FCNN_2L_1out_FB1_21->name+64)='k';
*(FCNN_2L_1out_FB1_21->name+65)='_';
*(FCNN_2L_1out_FB1_21->name+66)='2';
*(FCNN_2L_1out_FB1_21->name+67)='>';
*(FCNN_2L_1out_FB1_21->name+68)='1';
*(FCNN_2L_1out_FB1_21->name+69)=')';
*(FCNN_2L_1out_FB1_21->name+70)=' ';
FCNN_2L_1out_FB1_21->number_of_Levels=2;
FCNN_2L_1out_FB1_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FB1_21->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_21->number_of_Levels);
*(FCNN_2L_1out_FB1_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_21->recurrence=T;
FCNN_2L_1out_FB1_21->number_of_recurrent_connected_layers=1;
FCNN_2L_1out_FB1_21->source=MAI((long int)FCNN_2L_1out_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_21->source+0)=2;
FCNN_2L_1out_FB1_21->destination=MAI((long int)FCNN_2L_1out_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_21->destination+0)=1;
FCNN_2L_1out_FB1_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_21->create_neuron==0) exit_handling(84,1);
*(FCNN_2L_1out_FB1_21->create_neuron+0)=create_FCNN_2L_1out_FB1_21;
FCNN_2L_1out_FB1_21->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_21->prepare_input=0;
FCNN_2L_1out_FB1_21->number_linear_output_functions=3;
FCNN_2L_1out_FB1_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21->node_linear_output==0) exit_handling(84,2);
*(FCNN_2L_1out_FB1_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_21->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_21->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21->node_output==0) exit_handling(84,3);
*(FCNN_2L_1out_FB1_21->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21->node_output_derivation==0) exit_handling(84,4);
*(FCNN_2L_1out_FB1_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_21->number_of_firing_functions=2;
FCNN_2L_1out_FB1_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21->firing_neuron==0) exit_handling(84,5);
*(FCNN_2L_1out_FB1_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_1out_FB1_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_1out_FB1_21->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_21->create_learning_algorithm==0) exit_handling(84,6);
*(FCNN_2L_1out_FB1_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_21);
} /* ; */
/* setting up FCNN_2L_1out_FB1_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_22_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_22_11;
FCNN_2L_1out_FB1_22_11=MANTD((long int)1);
FCNN_2L_1out_FB1_22_11->name=MAC((long int)78);
*(FCNN_2L_1out_FB1_22_11->name+0)='F';
*(FCNN_2L_1out_FB1_22_11->name+1)='C';
*(FCNN_2L_1out_FB1_22_11->name+2)='N';
*(FCNN_2L_1out_FB1_22_11->name+3)='N';
*(FCNN_2L_1out_FB1_22_11->name+4)='_';
*(FCNN_2L_1out_FB1_22_11->name+5)='2';
*(FCNN_2L_1out_FB1_22_11->name+6)='L';
*(FCNN_2L_1out_FB1_22_11->name+7)='_';
*(FCNN_2L_1out_FB1_22_11->name+8)='1';
*(FCNN_2L_1out_FB1_22_11->name+9)='o';
*(FCNN_2L_1out_FB1_22_11->name+10)='u';
*(FCNN_2L_1out_FB1_22_11->name+11)='t';
*(FCNN_2L_1out_FB1_22_11->name+12)='_';
*(FCNN_2L_1out_FB1_22_11->name+13)='F';
*(FCNN_2L_1out_FB1_22_11->name+14)='B';
*(FCNN_2L_1out_FB1_22_11->name+15)='1';
*(FCNN_2L_1out_FB1_22_11->name+16)='_';
*(FCNN_2L_1out_FB1_22_11->name+17)='2';
*(FCNN_2L_1out_FB1_22_11->name+18)='2';
*(FCNN_2L_1out_FB1_22_11->name+19)='_';
*(FCNN_2L_1out_FB1_22_11->name+20)='1';
*(FCNN_2L_1out_FB1_22_11->name+21)='1';
*(FCNN_2L_1out_FB1_22_11->name+22)='(';
*(FCNN_2L_1out_FB1_22_11->name+23)='F';
*(FCNN_2L_1out_FB1_22_11->name+24)='u';
*(FCNN_2L_1out_FB1_22_11->name+25)='l';
*(FCNN_2L_1out_FB1_22_11->name+26)='l';
*(FCNN_2L_1out_FB1_22_11->name+27)='y';
*(FCNN_2L_1out_FB1_22_11->name+28)='_';
*(FCNN_2L_1out_FB1_22_11->name+29)='C';
*(FCNN_2L_1out_FB1_22_11->name+30)='o';
*(FCNN_2L_1out_FB1_22_11->name+31)='n';
*(FCNN_2L_1out_FB1_22_11->name+32)='n';
*(FCNN_2L_1out_FB1_22_11->name+33)='e';
*(FCNN_2L_1out_FB1_22_11->name+34)='c';
*(FCNN_2L_1out_FB1_22_11->name+35)='t';
*(FCNN_2L_1out_FB1_22_11->name+36)='e';
*(FCNN_2L_1out_FB1_22_11->name+37)='d';
*(FCNN_2L_1out_FB1_22_11->name+38)='_';
*(FCNN_2L_1out_FB1_22_11->name+39)='N';
*(FCNN_2L_1out_FB1_22_11->name+40)='N';
*(FCNN_2L_1out_FB1_22_11->name+41)='_';
*(FCNN_2L_1out_FB1_22_11->name+42)='2';
*(FCNN_2L_1out_FB1_22_11->name+43)='_';
*(FCNN_2L_1out_FB1_22_11->name+44)='L';
*(FCNN_2L_1out_FB1_22_11->name+45)='a';
*(FCNN_2L_1out_FB1_22_11->name+46)='y';
*(FCNN_2L_1out_FB1_22_11->name+47)='e';
*(FCNN_2L_1out_FB1_22_11->name+48)='r';
*(FCNN_2L_1out_FB1_22_11->name+49)='s';
*(FCNN_2L_1out_FB1_22_11->name+50)='_';
*(FCNN_2L_1out_FB1_22_11->name+51)='1';
*(FCNN_2L_1out_FB1_22_11->name+52)='_';
*(FCNN_2L_1out_FB1_22_11->name+53)='o';
*(FCNN_2L_1out_FB1_22_11->name+54)='u';
*(FCNN_2L_1out_FB1_22_11->name+55)='t';
*(FCNN_2L_1out_FB1_22_11->name+56)='p';
*(FCNN_2L_1out_FB1_22_11->name+57)='u';
*(FCNN_2L_1out_FB1_22_11->name+58)='t';
*(FCNN_2L_1out_FB1_22_11->name+59)='_';
*(FCNN_2L_1out_FB1_22_11->name+60)='f';
*(FCNN_2L_1out_FB1_22_11->name+61)='e';
*(FCNN_2L_1out_FB1_22_11->name+62)='e';
*(FCNN_2L_1out_FB1_22_11->name+63)='d';
*(FCNN_2L_1out_FB1_22_11->name+64)='b';
*(FCNN_2L_1out_FB1_22_11->name+65)='a';
*(FCNN_2L_1out_FB1_22_11->name+66)='c';
*(FCNN_2L_1out_FB1_22_11->name+67)='k';
*(FCNN_2L_1out_FB1_22_11->name+68)='_';
*(FCNN_2L_1out_FB1_22_11->name+69)='2';
*(FCNN_2L_1out_FB1_22_11->name+70)='>';
*(FCNN_2L_1out_FB1_22_11->name+71)='2';
*(FCNN_2L_1out_FB1_22_11->name+72)='_';
*(FCNN_2L_1out_FB1_22_11->name+73)='1';
*(FCNN_2L_1out_FB1_22_11->name+74)='>';
*(FCNN_2L_1out_FB1_22_11->name+75)='1';
*(FCNN_2L_1out_FB1_22_11->name+76)=')';
*(FCNN_2L_1out_FB1_22_11->name+77)=' ';
FCNN_2L_1out_FB1_22_11->number_of_Levels=2;
FCNN_2L_1out_FB1_22_11->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FB1_22_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_22_11->number_of_Levels);
*(FCNN_2L_1out_FB1_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_22_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_22_11->recurrence=T;
FCNN_2L_1out_FB1_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_1out_FB1_22_11->source=MAI((long int)FCNN_2L_1out_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22_11->source+0)=2;
*(FCNN_2L_1out_FB1_22_11->source+1)=1;
FCNN_2L_1out_FB1_22_11->destination=MAI((long int)FCNN_2L_1out_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22_11->destination+0)=2;
*(FCNN_2L_1out_FB1_22_11->destination+1)=1;
FCNN_2L_1out_FB1_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_22_11->create_neuron==0) exit_handling(85,1);
*(FCNN_2L_1out_FB1_22_11->create_neuron+0)=create_FCNN_2L_1out_FB1_22_11;
FCNN_2L_1out_FB1_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_22_11->prepare_input=0;
FCNN_2L_1out_FB1_22_11->number_linear_output_functions=3;
FCNN_2L_1out_FB1_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_11->node_linear_output==0) exit_handling(85,2);
*(FCNN_2L_1out_FB1_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_22_11->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_11->node_output==0) exit_handling(85,3);
*(FCNN_2L_1out_FB1_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_11->node_output_derivation==0) exit_handling(85,4);
*(FCNN_2L_1out_FB1_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_22_11->number_of_firing_functions=2;
FCNN_2L_1out_FB1_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_11->firing_neuron==0) exit_handling(85,5);
*(FCNN_2L_1out_FB1_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FB1_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FB1_22_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_22_11->create_learning_algorithm==0) exit_handling(85,6);
*(FCNN_2L_1out_FB1_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_22_11);
} /* ; */
/* setting up FCNN_2L_1out_FB1_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_21_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_21_11;
FCNN_2L_1out_FB1_21_11=MANTD((long int)1);
FCNN_2L_1out_FB1_21_11->name=MAC((long int)78);
*(FCNN_2L_1out_FB1_21_11->name+0)='F';
*(FCNN_2L_1out_FB1_21_11->name+1)='C';
*(FCNN_2L_1out_FB1_21_11->name+2)='N';
*(FCNN_2L_1out_FB1_21_11->name+3)='N';
*(FCNN_2L_1out_FB1_21_11->name+4)='_';
*(FCNN_2L_1out_FB1_21_11->name+5)='2';
*(FCNN_2L_1out_FB1_21_11->name+6)='L';
*(FCNN_2L_1out_FB1_21_11->name+7)='_';
*(FCNN_2L_1out_FB1_21_11->name+8)='1';
*(FCNN_2L_1out_FB1_21_11->name+9)='o';
*(FCNN_2L_1out_FB1_21_11->name+10)='u';
*(FCNN_2L_1out_FB1_21_11->name+11)='t';
*(FCNN_2L_1out_FB1_21_11->name+12)='_';
*(FCNN_2L_1out_FB1_21_11->name+13)='F';
*(FCNN_2L_1out_FB1_21_11->name+14)='B';
*(FCNN_2L_1out_FB1_21_11->name+15)='1';
*(FCNN_2L_1out_FB1_21_11->name+16)='_';
*(FCNN_2L_1out_FB1_21_11->name+17)='2';
*(FCNN_2L_1out_FB1_21_11->name+18)='1';
*(FCNN_2L_1out_FB1_21_11->name+19)='_';
*(FCNN_2L_1out_FB1_21_11->name+20)='1';
*(FCNN_2L_1out_FB1_21_11->name+21)='1';
*(FCNN_2L_1out_FB1_21_11->name+22)='(';
*(FCNN_2L_1out_FB1_21_11->name+23)='F';
*(FCNN_2L_1out_FB1_21_11->name+24)='u';
*(FCNN_2L_1out_FB1_21_11->name+25)='l';
*(FCNN_2L_1out_FB1_21_11->name+26)='l';
*(FCNN_2L_1out_FB1_21_11->name+27)='y';
*(FCNN_2L_1out_FB1_21_11->name+28)='_';
*(FCNN_2L_1out_FB1_21_11->name+29)='C';
*(FCNN_2L_1out_FB1_21_11->name+30)='o';
*(FCNN_2L_1out_FB1_21_11->name+31)='n';
*(FCNN_2L_1out_FB1_21_11->name+32)='n';
*(FCNN_2L_1out_FB1_21_11->name+33)='e';
*(FCNN_2L_1out_FB1_21_11->name+34)='c';
*(FCNN_2L_1out_FB1_21_11->name+35)='t';
*(FCNN_2L_1out_FB1_21_11->name+36)='e';
*(FCNN_2L_1out_FB1_21_11->name+37)='d';
*(FCNN_2L_1out_FB1_21_11->name+38)='_';
*(FCNN_2L_1out_FB1_21_11->name+39)='N';
*(FCNN_2L_1out_FB1_21_11->name+40)='N';
*(FCNN_2L_1out_FB1_21_11->name+41)='_';
*(FCNN_2L_1out_FB1_21_11->name+42)='2';
*(FCNN_2L_1out_FB1_21_11->name+43)='_';
*(FCNN_2L_1out_FB1_21_11->name+44)='L';
*(FCNN_2L_1out_FB1_21_11->name+45)='a';
*(FCNN_2L_1out_FB1_21_11->name+46)='y';
*(FCNN_2L_1out_FB1_21_11->name+47)='e';
*(FCNN_2L_1out_FB1_21_11->name+48)='r';
*(FCNN_2L_1out_FB1_21_11->name+49)='s';
*(FCNN_2L_1out_FB1_21_11->name+50)='_';
*(FCNN_2L_1out_FB1_21_11->name+51)='1';
*(FCNN_2L_1out_FB1_21_11->name+52)='_';
*(FCNN_2L_1out_FB1_21_11->name+53)='o';
*(FCNN_2L_1out_FB1_21_11->name+54)='u';
*(FCNN_2L_1out_FB1_21_11->name+55)='t';
*(FCNN_2L_1out_FB1_21_11->name+56)='p';
*(FCNN_2L_1out_FB1_21_11->name+57)='u';
*(FCNN_2L_1out_FB1_21_11->name+58)='t';
*(FCNN_2L_1out_FB1_21_11->name+59)='_';
*(FCNN_2L_1out_FB1_21_11->name+60)='f';
*(FCNN_2L_1out_FB1_21_11->name+61)='e';
*(FCNN_2L_1out_FB1_21_11->name+62)='e';
*(FCNN_2L_1out_FB1_21_11->name+63)='d';
*(FCNN_2L_1out_FB1_21_11->name+64)='b';
*(FCNN_2L_1out_FB1_21_11->name+65)='a';
*(FCNN_2L_1out_FB1_21_11->name+66)='c';
*(FCNN_2L_1out_FB1_21_11->name+67)='k';
*(FCNN_2L_1out_FB1_21_11->name+68)='_';
*(FCNN_2L_1out_FB1_21_11->name+69)='2';
*(FCNN_2L_1out_FB1_21_11->name+70)='>';
*(FCNN_2L_1out_FB1_21_11->name+71)='1';
*(FCNN_2L_1out_FB1_21_11->name+72)='_';
*(FCNN_2L_1out_FB1_21_11->name+73)='1';
*(FCNN_2L_1out_FB1_21_11->name+74)='>';
*(FCNN_2L_1out_FB1_21_11->name+75)='1';
*(FCNN_2L_1out_FB1_21_11->name+76)=')';
*(FCNN_2L_1out_FB1_21_11->name+77)=' ';
FCNN_2L_1out_FB1_21_11->number_of_Levels=2;
FCNN_2L_1out_FB1_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedbacks */
FCNN_2L_1out_FB1_21_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_21_11->number_of_Levels);
*(FCNN_2L_1out_FB1_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_21_11->recurrence=T;
FCNN_2L_1out_FB1_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_1out_FB1_21_11->source=MAI((long int)FCNN_2L_1out_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_21_11->source+0)=2;
*(FCNN_2L_1out_FB1_21_11->source+1)=1;
FCNN_2L_1out_FB1_21_11->destination=MAI((long int)FCNN_2L_1out_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_21_11->destination+0)=1;
*(FCNN_2L_1out_FB1_21_11->destination+1)=1;
FCNN_2L_1out_FB1_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_21_11->create_neuron==0) exit_handling(86,1);
*(FCNN_2L_1out_FB1_21_11->create_neuron+0)=create_FCNN_2L_1out_FB1_21_11;
FCNN_2L_1out_FB1_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_21_11->prepare_input=0;
FCNN_2L_1out_FB1_21_11->number_linear_output_functions=3;
FCNN_2L_1out_FB1_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21_11->node_linear_output==0) exit_handling(86,2);
*(FCNN_2L_1out_FB1_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_21_11->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21_11->node_output==0) exit_handling(86,3);
*(FCNN_2L_1out_FB1_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21_11->node_output_derivation==0) exit_handling(86,4);
*(FCNN_2L_1out_FB1_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_21_11->number_of_firing_functions=2;
FCNN_2L_1out_FB1_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_21_11->firing_neuron==0) exit_handling(86,5);
*(FCNN_2L_1out_FB1_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FB1_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FB1_21_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_21_11->create_learning_algorithm==0) exit_handling(86,6);
*(FCNN_2L_1out_FB1_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_21_11);
} /* ; */
/* setting up FCNN_2L_1out_FB1_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_22_21 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_22_21;
FCNN_2L_1out_FB1_22_21=MANTD((long int)1);
FCNN_2L_1out_FB1_22_21->name=MAC((long int)78);
*(FCNN_2L_1out_FB1_22_21->name+0)='F';
*(FCNN_2L_1out_FB1_22_21->name+1)='C';
*(FCNN_2L_1out_FB1_22_21->name+2)='N';
*(FCNN_2L_1out_FB1_22_21->name+3)='N';
*(FCNN_2L_1out_FB1_22_21->name+4)='_';
*(FCNN_2L_1out_FB1_22_21->name+5)='2';
*(FCNN_2L_1out_FB1_22_21->name+6)='L';
*(FCNN_2L_1out_FB1_22_21->name+7)='_';
*(FCNN_2L_1out_FB1_22_21->name+8)='1';
*(FCNN_2L_1out_FB1_22_21->name+9)='o';
*(FCNN_2L_1out_FB1_22_21->name+10)='u';
*(FCNN_2L_1out_FB1_22_21->name+11)='t';
*(FCNN_2L_1out_FB1_22_21->name+12)='_';
*(FCNN_2L_1out_FB1_22_21->name+13)='F';
*(FCNN_2L_1out_FB1_22_21->name+14)='B';
*(FCNN_2L_1out_FB1_22_21->name+15)='1';
*(FCNN_2L_1out_FB1_22_21->name+16)='_';
*(FCNN_2L_1out_FB1_22_21->name+17)='2';
*(FCNN_2L_1out_FB1_22_21->name+18)='2';
*(FCNN_2L_1out_FB1_22_21->name+19)='_';
*(FCNN_2L_1out_FB1_22_21->name+20)='2';
*(FCNN_2L_1out_FB1_22_21->name+21)='1';
*(FCNN_2L_1out_FB1_22_21->name+22)='(';
*(FCNN_2L_1out_FB1_22_21->name+23)='F';
*(FCNN_2L_1out_FB1_22_21->name+24)='u';
*(FCNN_2L_1out_FB1_22_21->name+25)='l';
*(FCNN_2L_1out_FB1_22_21->name+26)='l';
*(FCNN_2L_1out_FB1_22_21->name+27)='y';
*(FCNN_2L_1out_FB1_22_21->name+28)='_';
*(FCNN_2L_1out_FB1_22_21->name+29)='C';
*(FCNN_2L_1out_FB1_22_21->name+30)='o';
*(FCNN_2L_1out_FB1_22_21->name+31)='n';
*(FCNN_2L_1out_FB1_22_21->name+32)='n';
*(FCNN_2L_1out_FB1_22_21->name+33)='e';
*(FCNN_2L_1out_FB1_22_21->name+34)='c';
*(FCNN_2L_1out_FB1_22_21->name+35)='t';
*(FCNN_2L_1out_FB1_22_21->name+36)='e';
*(FCNN_2L_1out_FB1_22_21->name+37)='d';
*(FCNN_2L_1out_FB1_22_21->name+38)='_';
*(FCNN_2L_1out_FB1_22_21->name+39)='N';
*(FCNN_2L_1out_FB1_22_21->name+40)='N';
*(FCNN_2L_1out_FB1_22_21->name+41)='_';
*(FCNN_2L_1out_FB1_22_21->name+42)='2';
*(FCNN_2L_1out_FB1_22_21->name+43)='_';
*(FCNN_2L_1out_FB1_22_21->name+44)='L';
*(FCNN_2L_1out_FB1_22_21->name+45)='a';
*(FCNN_2L_1out_FB1_22_21->name+46)='y';
*(FCNN_2L_1out_FB1_22_21->name+47)='e';
*(FCNN_2L_1out_FB1_22_21->name+48)='r';
*(FCNN_2L_1out_FB1_22_21->name+49)='s';
*(FCNN_2L_1out_FB1_22_21->name+50)='_';
*(FCNN_2L_1out_FB1_22_21->name+51)='1';
*(FCNN_2L_1out_FB1_22_21->name+52)='_';
*(FCNN_2L_1out_FB1_22_21->name+53)='o';
*(FCNN_2L_1out_FB1_22_21->name+54)='u';
*(FCNN_2L_1out_FB1_22_21->name+55)='t';
*(FCNN_2L_1out_FB1_22_21->name+56)='p';
*(FCNN_2L_1out_FB1_22_21->name+57)='u';
*(FCNN_2L_1out_FB1_22_21->name+58)='t';
*(FCNN_2L_1out_FB1_22_21->name+59)='_';
*(FCNN_2L_1out_FB1_22_21->name+60)='f';
*(FCNN_2L_1out_FB1_22_21->name+61)='e';
*(FCNN_2L_1out_FB1_22_21->name+62)='e';
*(FCNN_2L_1out_FB1_22_21->name+63)='d';
*(FCNN_2L_1out_FB1_22_21->name+64)='b';
*(FCNN_2L_1out_FB1_22_21->name+65)='a';
*(FCNN_2L_1out_FB1_22_21->name+66)='c';
*(FCNN_2L_1out_FB1_22_21->name+67)='k';
*(FCNN_2L_1out_FB1_22_21->name+68)='_';
*(FCNN_2L_1out_FB1_22_21->name+69)='2';
*(FCNN_2L_1out_FB1_22_21->name+70)='>';
*(FCNN_2L_1out_FB1_22_21->name+71)='2';
*(FCNN_2L_1out_FB1_22_21->name+72)='_';
*(FCNN_2L_1out_FB1_22_21->name+73)='2';
*(FCNN_2L_1out_FB1_22_21->name+74)='>';
*(FCNN_2L_1out_FB1_22_21->name+75)='1';
*(FCNN_2L_1out_FB1_22_21->name+76)=')';
*(FCNN_2L_1out_FB1_22_21->name+77)=' ';
FCNN_2L_1out_FB1_22_21->number_of_Levels=2;
FCNN_2L_1out_FB1_22_21->inputs_per_first_Level_node=2*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedback */
FCNN_2L_1out_FB1_22_21->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_22_21->number_of_Levels);
*(FCNN_2L_1out_FB1_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_22_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_22_21->recurrence=T;
FCNN_2L_1out_FB1_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_1out_FB1_22_21->source=MAI((long int)FCNN_2L_1out_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22_21->source+0)=2;
*(FCNN_2L_1out_FB1_22_21->source+1)=2;
FCNN_2L_1out_FB1_22_21->destination=MAI((long int)FCNN_2L_1out_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22_21->destination+0)=2;
*(FCNN_2L_1out_FB1_22_21->destination+1)=1;
FCNN_2L_1out_FB1_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21->create_neuron==0) exit_handling(87,1);
*(FCNN_2L_1out_FB1_22_21->create_neuron+0)=create_FCNN_2L_1out_FB1_22_21;
FCNN_2L_1out_FB1_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_22_21->prepare_input=0;
FCNN_2L_1out_FB1_22_21->number_linear_output_functions=3;
FCNN_2L_1out_FB1_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21->node_linear_output==0) exit_handling(87,2);
*(FCNN_2L_1out_FB1_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_22_21->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21->node_output==0) exit_handling(87,3);
*(FCNN_2L_1out_FB1_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21->node_output_derivation==0) exit_handling(87,4);
*(FCNN_2L_1out_FB1_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_22_21->number_of_firing_functions=2;
FCNN_2L_1out_FB1_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21->firing_neuron==0) exit_handling(87,5);
*(FCNN_2L_1out_FB1_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FB1_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FB1_22_21->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21->create_learning_algorithm==0) exit_handling(87,6);
*(FCNN_2L_1out_FB1_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_22_21);
} /* ; */
/* setting up FCNN_2L_1out_FB1_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_1out_FB1_22_21_11 (Fully Connected Neural Network with 2 Layers and only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_1out_FB1_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_1out_FB1_22_21_11;
FCNN_2L_1out_FB1_22_21_11=MANTD((long int)1);
FCNN_2L_1out_FB1_22_21_11->name=MAC((long int)85);
*(FCNN_2L_1out_FB1_22_21_11->name+0)='F';
*(FCNN_2L_1out_FB1_22_21_11->name+1)='C';
*(FCNN_2L_1out_FB1_22_21_11->name+2)='N';
*(FCNN_2L_1out_FB1_22_21_11->name+3)='N';
*(FCNN_2L_1out_FB1_22_21_11->name+4)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+5)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+6)='L';
*(FCNN_2L_1out_FB1_22_21_11->name+7)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+8)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+9)='o';
*(FCNN_2L_1out_FB1_22_21_11->name+10)='u';
*(FCNN_2L_1out_FB1_22_21_11->name+11)='t';
*(FCNN_2L_1out_FB1_22_21_11->name+12)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+13)='F';
*(FCNN_2L_1out_FB1_22_21_11->name+14)='B';
*(FCNN_2L_1out_FB1_22_21_11->name+15)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+16)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+17)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+18)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+19)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+20)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+21)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+22)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+23)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+24)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+25)='(';
*(FCNN_2L_1out_FB1_22_21_11->name+26)='F';
*(FCNN_2L_1out_FB1_22_21_11->name+27)='u';
*(FCNN_2L_1out_FB1_22_21_11->name+28)='l';
*(FCNN_2L_1out_FB1_22_21_11->name+29)='l';
*(FCNN_2L_1out_FB1_22_21_11->name+30)='y';
*(FCNN_2L_1out_FB1_22_21_11->name+31)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+32)='C';
*(FCNN_2L_1out_FB1_22_21_11->name+33)='o';
*(FCNN_2L_1out_FB1_22_21_11->name+34)='n';
*(FCNN_2L_1out_FB1_22_21_11->name+35)='n';
*(FCNN_2L_1out_FB1_22_21_11->name+36)='e';
*(FCNN_2L_1out_FB1_22_21_11->name+37)='c';
*(FCNN_2L_1out_FB1_22_21_11->name+38)='t';
*(FCNN_2L_1out_FB1_22_21_11->name+39)='e';
*(FCNN_2L_1out_FB1_22_21_11->name+40)='d';
*(FCNN_2L_1out_FB1_22_21_11->name+41)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+42)='N';
*(FCNN_2L_1out_FB1_22_21_11->name+43)='N';
*(FCNN_2L_1out_FB1_22_21_11->name+44)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+45)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+46)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+47)='L';
*(FCNN_2L_1out_FB1_22_21_11->name+48)='a';
*(FCNN_2L_1out_FB1_22_21_11->name+49)='y';
*(FCNN_2L_1out_FB1_22_21_11->name+50)='e';
*(FCNN_2L_1out_FB1_22_21_11->name+51)='r';
*(FCNN_2L_1out_FB1_22_21_11->name+52)='s';
*(FCNN_2L_1out_FB1_22_21_11->name+53)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+54)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+55)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+56)='o';
*(FCNN_2L_1out_FB1_22_21_11->name+57)='u';
*(FCNN_2L_1out_FB1_22_21_11->name+58)='t';
*(FCNN_2L_1out_FB1_22_21_11->name+59)='p';
*(FCNN_2L_1out_FB1_22_21_11->name+60)='u';
*(FCNN_2L_1out_FB1_22_21_11->name+61)='t';
*(FCNN_2L_1out_FB1_22_21_11->name+62)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+63)='f';
*(FCNN_2L_1out_FB1_22_21_11->name+64)='e';
*(FCNN_2L_1out_FB1_22_21_11->name+65)='e';
*(FCNN_2L_1out_FB1_22_21_11->name+66)='d';
*(FCNN_2L_1out_FB1_22_21_11->name+67)='b';
*(FCNN_2L_1out_FB1_22_21_11->name+68)='a';
*(FCNN_2L_1out_FB1_22_21_11->name+69)='c';
*(FCNN_2L_1out_FB1_22_21_11->name+70)='k';
*(FCNN_2L_1out_FB1_22_21_11->name+71)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+72)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+73)='>';
*(FCNN_2L_1out_FB1_22_21_11->name+74)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+75)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+76)='2';
*(FCNN_2L_1out_FB1_22_21_11->name+77)='>';
*(FCNN_2L_1out_FB1_22_21_11->name+78)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+79)='_';
*(FCNN_2L_1out_FB1_22_21_11->name+80)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+81)='>';
*(FCNN_2L_1out_FB1_22_21_11->name+82)='1';
*(FCNN_2L_1out_FB1_22_21_11->name+83)=')';
*(FCNN_2L_1out_FB1_22_21_11->name+84)=' ';
FCNN_2L_1out_FB1_22_21_11->number_of_Levels=2;
FCNN_2L_1out_FB1_22_21_11->inputs_per_first_Level_node=3*0; /* means all inputs are associated with all 1st Level nodes plus inputs from feedbacks */
FCNN_2L_1out_FB1_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_1out_FB1_22_21_11->number_of_Levels);
*(FCNN_2L_1out_FB1_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_1out_FB1_22_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_1out_FB1_22_21_11->recurrence=T;
FCNN_2L_1out_FB1_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_1out_FB1_22_21_11->source=MAI((long int)FCNN_2L_1out_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22_21_11->source+0)=2;
*(FCNN_2L_1out_FB1_22_21_11->source+1)=2;
*(FCNN_2L_1out_FB1_22_21_11->source+2)=1;
FCNN_2L_1out_FB1_22_21_11->destination=MAI((long int)FCNN_2L_1out_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_1out_FB1_22_21_11->destination+0)=2;
*(FCNN_2L_1out_FB1_22_21_11->destination+1)=1;
*(FCNN_2L_1out_FB1_22_21_11->destination+2)=1;
FCNN_2L_1out_FB1_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_1out_FB1_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21_11->create_neuron==0) exit_handling(88,1);
*(FCNN_2L_1out_FB1_22_21_11->create_neuron+0)=create_FCNN_2L_1out_FB1_22_21_11;
FCNN_2L_1out_FB1_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_1out_FB1_22_21_11->prepare_input=0;
FCNN_2L_1out_FB1_22_21_11->number_linear_output_functions=3;
FCNN_2L_1out_FB1_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21_11->node_linear_output==0) exit_handling(88,2);
*(FCNN_2L_1out_FB1_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_1out_FB1_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_1out_FB1_22_21_11->number_of_node_output_functions=4;
FCNN_2L_1out_FB1_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21_11->node_output==0) exit_handling(88,3);
*(FCNN_2L_1out_FB1_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_1out_FB1_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_1out_FB1_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_1out_FB1_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_1out_FB1_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21_11->node_output_derivation==0) exit_handling(88,4);
*(FCNN_2L_1out_FB1_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_1out_FB1_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_1out_FB1_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_1out_FB1_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_1out_FB1_22_21_11->number_of_firing_functions=2;
FCNN_2L_1out_FB1_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21_11->firing_neuron==0) exit_handling(88,5);
*(FCNN_2L_1out_FB1_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_1out_FB1_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_1out_FB1_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_1out_FB1_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_1out_FB1_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_1out_FB1_22_21_11->create_learning_algorithm==0) exit_handling(88,6);
*(FCNN_2L_1out_FB1_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_1out_FB1_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_1out_FB1_22_21_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_11;
FCNN_2L_W_1out_FB1_11=MANTD((long int)1);
FCNN_2L_W_1out_FB1_11->name=MAC((long int)104);
*(FCNN_2L_W_1out_FB1_11->name+0)='F';
*(FCNN_2L_W_1out_FB1_11->name+1)='C';
*(FCNN_2L_W_1out_FB1_11->name+2)='N';
*(FCNN_2L_W_1out_FB1_11->name+3)='N';
*(FCNN_2L_W_1out_FB1_11->name+4)='_';
*(FCNN_2L_W_1out_FB1_11->name+5)='2';
*(FCNN_2L_W_1out_FB1_11->name+6)='L';
*(FCNN_2L_W_1out_FB1_11->name+7)='_';
*(FCNN_2L_W_1out_FB1_11->name+8)='W';
*(FCNN_2L_W_1out_FB1_11->name+9)='_';
*(FCNN_2L_W_1out_FB1_11->name+10)='1';
*(FCNN_2L_W_1out_FB1_11->name+11)='o';
*(FCNN_2L_W_1out_FB1_11->name+12)='u';
*(FCNN_2L_W_1out_FB1_11->name+13)='t';
*(FCNN_2L_W_1out_FB1_11->name+14)='_';
*(FCNN_2L_W_1out_FB1_11->name+15)='F';
*(FCNN_2L_W_1out_FB1_11->name+16)='B';
*(FCNN_2L_W_1out_FB1_11->name+17)='1';
*(FCNN_2L_W_1out_FB1_11->name+18)='_';
*(FCNN_2L_W_1out_FB1_11->name+19)='1';
*(FCNN_2L_W_1out_FB1_11->name+20)='1';
*(FCNN_2L_W_1out_FB1_11->name+21)='(';
*(FCNN_2L_W_1out_FB1_11->name+22)='F';
*(FCNN_2L_W_1out_FB1_11->name+23)='u';
*(FCNN_2L_W_1out_FB1_11->name+24)='l';
*(FCNN_2L_W_1out_FB1_11->name+25)='l';
*(FCNN_2L_W_1out_FB1_11->name+26)='y';
*(FCNN_2L_W_1out_FB1_11->name+27)='_';
*(FCNN_2L_W_1out_FB1_11->name+28)='C';
*(FCNN_2L_W_1out_FB1_11->name+29)='o';
*(FCNN_2L_W_1out_FB1_11->name+30)='n';
*(FCNN_2L_W_1out_FB1_11->name+31)='n';
*(FCNN_2L_W_1out_FB1_11->name+32)='e';
*(FCNN_2L_W_1out_FB1_11->name+33)='c';
*(FCNN_2L_W_1out_FB1_11->name+34)='t';
*(FCNN_2L_W_1out_FB1_11->name+35)='e';
*(FCNN_2L_W_1out_FB1_11->name+36)='d';
*(FCNN_2L_W_1out_FB1_11->name+37)='_';
*(FCNN_2L_W_1out_FB1_11->name+38)='N';
*(FCNN_2L_W_1out_FB1_11->name+39)='N';
*(FCNN_2L_W_1out_FB1_11->name+40)='_';
*(FCNN_2L_W_1out_FB1_11->name+41)='2';
*(FCNN_2L_W_1out_FB1_11->name+42)='_';
*(FCNN_2L_W_1out_FB1_11->name+43)='L';
*(FCNN_2L_W_1out_FB1_11->name+44)='a';
*(FCNN_2L_W_1out_FB1_11->name+45)='y';
*(FCNN_2L_W_1out_FB1_11->name+46)='e';
*(FCNN_2L_W_1out_FB1_11->name+47)='r';
*(FCNN_2L_W_1out_FB1_11->name+48)='s';
*(FCNN_2L_W_1out_FB1_11->name+49)='_';
*(FCNN_2L_W_1out_FB1_11->name+50)='r';
*(FCNN_2L_W_1out_FB1_11->name+51)='e';
*(FCNN_2L_W_1out_FB1_11->name+52)='c';
*(FCNN_2L_W_1out_FB1_11->name+53)='e';
*(FCNN_2L_W_1out_FB1_11->name+54)='i';
*(FCNN_2L_W_1out_FB1_11->name+55)='v';
*(FCNN_2L_W_1out_FB1_11->name+56)='i';
*(FCNN_2L_W_1out_FB1_11->name+57)='n';
*(FCNN_2L_W_1out_FB1_11->name+58)='g';
*(FCNN_2L_W_1out_FB1_11->name+59)='_';
*(FCNN_2L_W_1out_FB1_11->name+60)='i';
*(FCNN_2L_W_1out_FB1_11->name+61)='n';
*(FCNN_2L_W_1out_FB1_11->name+62)='p';
*(FCNN_2L_W_1out_FB1_11->name+63)='u';
*(FCNN_2L_W_1out_FB1_11->name+64)='t';
*(FCNN_2L_W_1out_FB1_11->name+65)='_';
*(FCNN_2L_W_1out_FB1_11->name+66)='t';
*(FCNN_2L_W_1out_FB1_11->name+67)='h';
*(FCNN_2L_W_1out_FB1_11->name+68)='r';
*(FCNN_2L_W_1out_FB1_11->name+69)='o';
*(FCNN_2L_W_1out_FB1_11->name+70)='u';
*(FCNN_2L_W_1out_FB1_11->name+71)='g';
*(FCNN_2L_W_1out_FB1_11->name+72)='h';
*(FCNN_2L_W_1out_FB1_11->name+73)='_';
*(FCNN_2L_W_1out_FB1_11->name+74)='W';
*(FCNN_2L_W_1out_FB1_11->name+75)='i';
*(FCNN_2L_W_1out_FB1_11->name+76)='n';
*(FCNN_2L_W_1out_FB1_11->name+77)='d';
*(FCNN_2L_W_1out_FB1_11->name+78)='o';
*(FCNN_2L_W_1out_FB1_11->name+79)='w';
*(FCNN_2L_W_1out_FB1_11->name+80)='_';
*(FCNN_2L_W_1out_FB1_11->name+81)='1';
*(FCNN_2L_W_1out_FB1_11->name+82)='_';
*(FCNN_2L_W_1out_FB1_11->name+83)='o';
*(FCNN_2L_W_1out_FB1_11->name+84)='u';
*(FCNN_2L_W_1out_FB1_11->name+85)='t';
*(FCNN_2L_W_1out_FB1_11->name+86)='p';
*(FCNN_2L_W_1out_FB1_11->name+87)='u';
*(FCNN_2L_W_1out_FB1_11->name+88)='t';
*(FCNN_2L_W_1out_FB1_11->name+89)='_';
*(FCNN_2L_W_1out_FB1_11->name+90)='f';
*(FCNN_2L_W_1out_FB1_11->name+91)='e';
*(FCNN_2L_W_1out_FB1_11->name+92)='e';
*(FCNN_2L_W_1out_FB1_11->name+93)='d';
*(FCNN_2L_W_1out_FB1_11->name+94)='b';
*(FCNN_2L_W_1out_FB1_11->name+95)='a';
*(FCNN_2L_W_1out_FB1_11->name+96)='c';
*(FCNN_2L_W_1out_FB1_11->name+97)='k';
*(FCNN_2L_W_1out_FB1_11->name+98)='_';
*(FCNN_2L_W_1out_FB1_11->name+99)='1';
*(FCNN_2L_W_1out_FB1_11->name+100)='>';
*(FCNN_2L_W_1out_FB1_11->name+101)='1';
*(FCNN_2L_W_1out_FB1_11->name+102)=')';
*(FCNN_2L_W_1out_FB1_11->name+103)=' ';
FCNN_2L_W_1out_FB1_11->number_of_Levels=2;
FCNN_2L_W_1out_FB1_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_11->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FB1_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_11->number_of_Levels);
*(FCNN_2L_W_1out_FB1_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_11->recurrence=T;
FCNN_2L_W_1out_FB1_11->number_of_recurrent_connected_layers=1;
FCNN_2L_W_1out_FB1_11->source=MAI((long int)FCNN_2L_W_1out_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_11->source+0)=1;
FCNN_2L_W_1out_FB1_11->destination=MAI((long int)FCNN_2L_W_1out_FB1_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_11->destination+0)=1;
FCNN_2L_W_1out_FB1_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_11->create_neuron==0) exit_handling(89,1);
*(FCNN_2L_W_1out_FB1_11->create_neuron+0)=create_FCNN_2L_1out_FB1_11;
FCNN_2L_W_1out_FB1_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_11->node_linear_output==0) exit_handling(89,2);
*(FCNN_2L_W_1out_FB1_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_11->node_output==0) exit_handling(89,3);
*(FCNN_2L_W_1out_FB1_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_11->node_output_derivation==0) exit_handling(89,4);
*(FCNN_2L_W_1out_FB1_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_11->firing_neuron==0) exit_handling(89,5);
*(FCNN_2L_W_1out_FB1_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FB1_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FB1_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_11->create_learning_algorithm==0) exit_handling(89,6);
*(FCNN_2L_W_1out_FB1_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_22 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_22 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_22;
FCNN_2L_W_1out_FB1_22=MANTD((long int)1);
FCNN_2L_W_1out_FB1_22->name=MAC((long int)104);
*(FCNN_2L_W_1out_FB1_22->name+0)='F';
*(FCNN_2L_W_1out_FB1_22->name+1)='C';
*(FCNN_2L_W_1out_FB1_22->name+2)='N';
*(FCNN_2L_W_1out_FB1_22->name+3)='N';
*(FCNN_2L_W_1out_FB1_22->name+4)='_';
*(FCNN_2L_W_1out_FB1_22->name+5)='2';
*(FCNN_2L_W_1out_FB1_22->name+6)='L';
*(FCNN_2L_W_1out_FB1_22->name+7)='_';
*(FCNN_2L_W_1out_FB1_22->name+8)='W';
*(FCNN_2L_W_1out_FB1_22->name+9)='_';
*(FCNN_2L_W_1out_FB1_22->name+10)='1';
*(FCNN_2L_W_1out_FB1_22->name+11)='o';
*(FCNN_2L_W_1out_FB1_22->name+12)='u';
*(FCNN_2L_W_1out_FB1_22->name+13)='t';
*(FCNN_2L_W_1out_FB1_22->name+14)='_';
*(FCNN_2L_W_1out_FB1_22->name+15)='F';
*(FCNN_2L_W_1out_FB1_22->name+16)='B';
*(FCNN_2L_W_1out_FB1_22->name+17)='1';
*(FCNN_2L_W_1out_FB1_22->name+18)='_';
*(FCNN_2L_W_1out_FB1_22->name+19)='2';
*(FCNN_2L_W_1out_FB1_22->name+20)='2';
*(FCNN_2L_W_1out_FB1_22->name+21)='(';
*(FCNN_2L_W_1out_FB1_22->name+22)='F';
*(FCNN_2L_W_1out_FB1_22->name+23)='u';
*(FCNN_2L_W_1out_FB1_22->name+24)='l';
*(FCNN_2L_W_1out_FB1_22->name+25)='l';
*(FCNN_2L_W_1out_FB1_22->name+26)='y';
*(FCNN_2L_W_1out_FB1_22->name+27)='_';
*(FCNN_2L_W_1out_FB1_22->name+28)='C';
*(FCNN_2L_W_1out_FB1_22->name+29)='o';
*(FCNN_2L_W_1out_FB1_22->name+30)='n';
*(FCNN_2L_W_1out_FB1_22->name+31)='n';
*(FCNN_2L_W_1out_FB1_22->name+32)='e';
*(FCNN_2L_W_1out_FB1_22->name+33)='c';
*(FCNN_2L_W_1out_FB1_22->name+34)='t';
*(FCNN_2L_W_1out_FB1_22->name+35)='e';
*(FCNN_2L_W_1out_FB1_22->name+36)='d';
*(FCNN_2L_W_1out_FB1_22->name+37)='_';
*(FCNN_2L_W_1out_FB1_22->name+38)='N';
*(FCNN_2L_W_1out_FB1_22->name+39)='N';
*(FCNN_2L_W_1out_FB1_22->name+40)='_';
*(FCNN_2L_W_1out_FB1_22->name+41)='2';
*(FCNN_2L_W_1out_FB1_22->name+42)='_';
*(FCNN_2L_W_1out_FB1_22->name+43)='L';
*(FCNN_2L_W_1out_FB1_22->name+44)='a';
*(FCNN_2L_W_1out_FB1_22->name+45)='y';
*(FCNN_2L_W_1out_FB1_22->name+46)='e';
*(FCNN_2L_W_1out_FB1_22->name+47)='r';
*(FCNN_2L_W_1out_FB1_22->name+48)='s';
*(FCNN_2L_W_1out_FB1_22->name+49)='_';
*(FCNN_2L_W_1out_FB1_22->name+50)='r';
*(FCNN_2L_W_1out_FB1_22->name+51)='e';
*(FCNN_2L_W_1out_FB1_22->name+52)='c';
*(FCNN_2L_W_1out_FB1_22->name+53)='e';
*(FCNN_2L_W_1out_FB1_22->name+54)='i';
*(FCNN_2L_W_1out_FB1_22->name+55)='v';
*(FCNN_2L_W_1out_FB1_22->name+56)='i';
*(FCNN_2L_W_1out_FB1_22->name+57)='n';
*(FCNN_2L_W_1out_FB1_22->name+58)='g';
*(FCNN_2L_W_1out_FB1_22->name+59)='_';
*(FCNN_2L_W_1out_FB1_22->name+60)='i';
*(FCNN_2L_W_1out_FB1_22->name+61)='n';
*(FCNN_2L_W_1out_FB1_22->name+62)='p';
*(FCNN_2L_W_1out_FB1_22->name+63)='u';
*(FCNN_2L_W_1out_FB1_22->name+64)='t';
*(FCNN_2L_W_1out_FB1_22->name+65)='_';
*(FCNN_2L_W_1out_FB1_22->name+66)='t';
*(FCNN_2L_W_1out_FB1_22->name+67)='h';
*(FCNN_2L_W_1out_FB1_22->name+68)='r';
*(FCNN_2L_W_1out_FB1_22->name+69)='o';
*(FCNN_2L_W_1out_FB1_22->name+70)='u';
*(FCNN_2L_W_1out_FB1_22->name+71)='g';
*(FCNN_2L_W_1out_FB1_22->name+72)='h';
*(FCNN_2L_W_1out_FB1_22->name+73)='_';
*(FCNN_2L_W_1out_FB1_22->name+74)='W';
*(FCNN_2L_W_1out_FB1_22->name+75)='i';
*(FCNN_2L_W_1out_FB1_22->name+76)='n';
*(FCNN_2L_W_1out_FB1_22->name+77)='d';
*(FCNN_2L_W_1out_FB1_22->name+78)='o';
*(FCNN_2L_W_1out_FB1_22->name+79)='w';
*(FCNN_2L_W_1out_FB1_22->name+80)='_';
*(FCNN_2L_W_1out_FB1_22->name+81)='1';
*(FCNN_2L_W_1out_FB1_22->name+82)='_';
*(FCNN_2L_W_1out_FB1_22->name+83)='o';
*(FCNN_2L_W_1out_FB1_22->name+84)='u';
*(FCNN_2L_W_1out_FB1_22->name+85)='t';
*(FCNN_2L_W_1out_FB1_22->name+86)='p';
*(FCNN_2L_W_1out_FB1_22->name+87)='u';
*(FCNN_2L_W_1out_FB1_22->name+88)='t';
*(FCNN_2L_W_1out_FB1_22->name+89)='_';
*(FCNN_2L_W_1out_FB1_22->name+90)='f';
*(FCNN_2L_W_1out_FB1_22->name+91)='e';
*(FCNN_2L_W_1out_FB1_22->name+92)='e';
*(FCNN_2L_W_1out_FB1_22->name+93)='d';
*(FCNN_2L_W_1out_FB1_22->name+94)='b';
*(FCNN_2L_W_1out_FB1_22->name+95)='a';
*(FCNN_2L_W_1out_FB1_22->name+96)='c';
*(FCNN_2L_W_1out_FB1_22->name+97)='k';
*(FCNN_2L_W_1out_FB1_22->name+98)='_';
*(FCNN_2L_W_1out_FB1_22->name+99)='2';
*(FCNN_2L_W_1out_FB1_22->name+100)='>';
*(FCNN_2L_W_1out_FB1_22->name+101)='2';
*(FCNN_2L_W_1out_FB1_22->name+102)=')';
*(FCNN_2L_W_1out_FB1_22->name+103)=' ';
FCNN_2L_W_1out_FB1_22->number_of_Levels=2;
FCNN_2L_W_1out_FB1_22->inputs_per_first_Level_node=-5; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_22->prepare_input()) */
FCNN_2L_W_1out_FB1_22->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_22->number_of_Levels);
*(FCNN_2L_W_1out_FB1_22->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_22->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_22->recurrence=T;
FCNN_2L_W_1out_FB1_22->number_of_recurrent_connected_layers=1;
FCNN_2L_W_1out_FB1_22->source=MAI((long int)FCNN_2L_W_1out_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22->source+0)=2;
FCNN_2L_W_1out_FB1_22->destination=MAI((long int)FCNN_2L_W_1out_FB1_22->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22->destination+0)=2;
FCNN_2L_W_1out_FB1_22->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_22->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22->create_neuron==0) exit_handling(100,1);
*(FCNN_2L_W_1out_FB1_22->create_neuron+0)=create_FCNN_2L_1out_FB1_22;
FCNN_2L_W_1out_FB1_22->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_22->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_22->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_22->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22->node_linear_output==0) exit_handling(100,2);
*(FCNN_2L_W_1out_FB1_22->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_22->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_22->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22->node_output==0) exit_handling(100,3);
*(FCNN_2L_W_1out_FB1_22->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_22->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_22->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_22->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_22->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22->node_output_derivation==0) exit_handling(100,4);
*(FCNN_2L_W_1out_FB1_22->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_22->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_22->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22->firing_neuron==0) exit_handling(100,5);
*(FCNN_2L_W_1out_FB1_22->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FB1_22->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FB1_22->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_22->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22->create_learning_algorithm==0) exit_handling(100,6);
*(FCNN_2L_W_1out_FB1_22->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_22->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_22);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto the 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_21;
FCNN_2L_W_1out_FB1_21=MANTD((long int)1);
FCNN_2L_W_1out_FB1_21->name=MAC((long int)104);
*(FCNN_2L_W_1out_FB1_21->name+0)='F';
*(FCNN_2L_W_1out_FB1_21->name+1)='C';
*(FCNN_2L_W_1out_FB1_21->name+2)='N';
*(FCNN_2L_W_1out_FB1_21->name+3)='N';
*(FCNN_2L_W_1out_FB1_21->name+4)='_';
*(FCNN_2L_W_1out_FB1_21->name+5)='2';
*(FCNN_2L_W_1out_FB1_21->name+6)='L';
*(FCNN_2L_W_1out_FB1_21->name+7)='_';
*(FCNN_2L_W_1out_FB1_21->name+8)='W';
*(FCNN_2L_W_1out_FB1_21->name+9)='_';
*(FCNN_2L_W_1out_FB1_21->name+10)='1';
*(FCNN_2L_W_1out_FB1_21->name+11)='o';
*(FCNN_2L_W_1out_FB1_21->name+12)='u';
*(FCNN_2L_W_1out_FB1_21->name+13)='t';
*(FCNN_2L_W_1out_FB1_21->name+14)='_';
*(FCNN_2L_W_1out_FB1_21->name+15)='F';
*(FCNN_2L_W_1out_FB1_21->name+16)='B';
*(FCNN_2L_W_1out_FB1_21->name+17)='1';
*(FCNN_2L_W_1out_FB1_21->name+18)='_';
*(FCNN_2L_W_1out_FB1_21->name+19)='2';
*(FCNN_2L_W_1out_FB1_21->name+20)='1';
*(FCNN_2L_W_1out_FB1_21->name+21)='(';
*(FCNN_2L_W_1out_FB1_21->name+22)='F';
*(FCNN_2L_W_1out_FB1_21->name+23)='u';
*(FCNN_2L_W_1out_FB1_21->name+24)='l';
*(FCNN_2L_W_1out_FB1_21->name+25)='l';
*(FCNN_2L_W_1out_FB1_21->name+26)='y';
*(FCNN_2L_W_1out_FB1_21->name+27)='_';
*(FCNN_2L_W_1out_FB1_21->name+28)='C';
*(FCNN_2L_W_1out_FB1_21->name+29)='o';
*(FCNN_2L_W_1out_FB1_21->name+30)='n';
*(FCNN_2L_W_1out_FB1_21->name+31)='n';
*(FCNN_2L_W_1out_FB1_21->name+32)='e';
*(FCNN_2L_W_1out_FB1_21->name+33)='c';
*(FCNN_2L_W_1out_FB1_21->name+34)='t';
*(FCNN_2L_W_1out_FB1_21->name+35)='e';
*(FCNN_2L_W_1out_FB1_21->name+36)='d';
*(FCNN_2L_W_1out_FB1_21->name+37)='_';
*(FCNN_2L_W_1out_FB1_21->name+38)='N';
*(FCNN_2L_W_1out_FB1_21->name+39)='N';
*(FCNN_2L_W_1out_FB1_21->name+40)='_';
*(FCNN_2L_W_1out_FB1_21->name+41)='2';
*(FCNN_2L_W_1out_FB1_21->name+42)='_';
*(FCNN_2L_W_1out_FB1_21->name+43)='L';
*(FCNN_2L_W_1out_FB1_21->name+44)='a';
*(FCNN_2L_W_1out_FB1_21->name+45)='y';
*(FCNN_2L_W_1out_FB1_21->name+46)='e';
*(FCNN_2L_W_1out_FB1_21->name+47)='r';
*(FCNN_2L_W_1out_FB1_21->name+48)='s';
*(FCNN_2L_W_1out_FB1_21->name+49)='_';
*(FCNN_2L_W_1out_FB1_21->name+50)='r';
*(FCNN_2L_W_1out_FB1_21->name+51)='e';
*(FCNN_2L_W_1out_FB1_21->name+52)='c';
*(FCNN_2L_W_1out_FB1_21->name+53)='e';
*(FCNN_2L_W_1out_FB1_21->name+54)='i';
*(FCNN_2L_W_1out_FB1_21->name+55)='v';
*(FCNN_2L_W_1out_FB1_21->name+56)='i';
*(FCNN_2L_W_1out_FB1_21->name+57)='n';
*(FCNN_2L_W_1out_FB1_21->name+58)='g';
*(FCNN_2L_W_1out_FB1_21->name+59)='_';
*(FCNN_2L_W_1out_FB1_21->name+60)='i';
*(FCNN_2L_W_1out_FB1_21->name+61)='n';
*(FCNN_2L_W_1out_FB1_21->name+62)='p';
*(FCNN_2L_W_1out_FB1_21->name+63)='u';
*(FCNN_2L_W_1out_FB1_21->name+64)='t';
*(FCNN_2L_W_1out_FB1_21->name+65)='_';
*(FCNN_2L_W_1out_FB1_21->name+66)='t';
*(FCNN_2L_W_1out_FB1_21->name+67)='h';
*(FCNN_2L_W_1out_FB1_21->name+68)='r';
*(FCNN_2L_W_1out_FB1_21->name+69)='o';
*(FCNN_2L_W_1out_FB1_21->name+70)='u';
*(FCNN_2L_W_1out_FB1_21->name+71)='g';
*(FCNN_2L_W_1out_FB1_21->name+72)='h';
*(FCNN_2L_W_1out_FB1_21->name+73)='_';
*(FCNN_2L_W_1out_FB1_21->name+74)='W';
*(FCNN_2L_W_1out_FB1_21->name+75)='i';
*(FCNN_2L_W_1out_FB1_21->name+76)='n';
*(FCNN_2L_W_1out_FB1_21->name+77)='d';
*(FCNN_2L_W_1out_FB1_21->name+78)='o';
*(FCNN_2L_W_1out_FB1_21->name+79)='w';
*(FCNN_2L_W_1out_FB1_21->name+80)='_';
*(FCNN_2L_W_1out_FB1_21->name+81)='1';
*(FCNN_2L_W_1out_FB1_21->name+82)='_';
*(FCNN_2L_W_1out_FB1_21->name+83)='o';
*(FCNN_2L_W_1out_FB1_21->name+84)='u';
*(FCNN_2L_W_1out_FB1_21->name+85)='t';
*(FCNN_2L_W_1out_FB1_21->name+86)='p';
*(FCNN_2L_W_1out_FB1_21->name+87)='u';
*(FCNN_2L_W_1out_FB1_21->name+88)='t';
*(FCNN_2L_W_1out_FB1_21->name+89)='_';
*(FCNN_2L_W_1out_FB1_21->name+90)='f';
*(FCNN_2L_W_1out_FB1_21->name+91)='e';
*(FCNN_2L_W_1out_FB1_21->name+92)='e';
*(FCNN_2L_W_1out_FB1_21->name+93)='d';
*(FCNN_2L_W_1out_FB1_21->name+94)='b';
*(FCNN_2L_W_1out_FB1_21->name+95)='a';
*(FCNN_2L_W_1out_FB1_21->name+96)='c';
*(FCNN_2L_W_1out_FB1_21->name+97)='k';
*(FCNN_2L_W_1out_FB1_21->name+98)='_';
*(FCNN_2L_W_1out_FB1_21->name+99)='2';
*(FCNN_2L_W_1out_FB1_21->name+100)='>';
*(FCNN_2L_W_1out_FB1_21->name+101)='1';
*(FCNN_2L_W_1out_FB1_21->name+102)=')';
*(FCNN_2L_W_1out_FB1_21->name+103)=' ';
FCNN_2L_W_1out_FB1_21->number_of_Levels=2;
FCNN_2L_W_1out_FB1_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_21->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FB1_21->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_21->number_of_Levels);
*(FCNN_2L_W_1out_FB1_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_21->recurrence=T;
FCNN_2L_W_1out_FB1_21->number_of_recurrent_connected_layers=1;
FCNN_2L_W_1out_FB1_21->source=MAI((long int)FCNN_2L_W_1out_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_21->source+0)=2;
FCNN_2L_W_1out_FB1_21->destination=MAI((long int)FCNN_2L_W_1out_FB1_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_21->destination+0)=1;
FCNN_2L_W_1out_FB1_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21->create_neuron==0) exit_handling(101,1);
*(FCNN_2L_W_1out_FB1_21->create_neuron+0)=create_FCNN_2L_1out_FB1_21;
FCNN_2L_W_1out_FB1_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_21->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21->node_linear_output==0) exit_handling(101,2);
*(FCNN_2L_W_1out_FB1_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_21->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21->node_output==0) exit_handling(101,3);
*(FCNN_2L_W_1out_FB1_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21->node_output_derivation==0) exit_handling(101,4);
*(FCNN_2L_W_1out_FB1_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_21->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21->firing_neuron==0) exit_handling(101,5);
*(FCNN_2L_W_1out_FB1_21->firing_neuron+0)=firing_standard_neuron;
*(FCNN_2L_W_1out_FB1_21->firing_neuron+1)=firing_recurrent_neuron;
FCNN_2L_W_1out_FB1_21->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21->create_learning_algorithm==0) exit_handling(101,6);
*(FCNN_2L_W_1out_FB1_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_21);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_22_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_22_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_22_11;
FCNN_2L_W_1out_FB1_22_11=MANTD((long int)1);
FCNN_2L_W_1out_FB1_22_11->name=MAC((long int)111);
*(FCNN_2L_W_1out_FB1_22_11->name+0)='F';
*(FCNN_2L_W_1out_FB1_22_11->name+1)='C';
*(FCNN_2L_W_1out_FB1_22_11->name+2)='N';
*(FCNN_2L_W_1out_FB1_22_11->name+3)='N';
*(FCNN_2L_W_1out_FB1_22_11->name+4)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+5)='2';
*(FCNN_2L_W_1out_FB1_22_11->name+6)='L';
*(FCNN_2L_W_1out_FB1_22_11->name+7)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+8)='W';
*(FCNN_2L_W_1out_FB1_22_11->name+9)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+10)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+11)='o';
*(FCNN_2L_W_1out_FB1_22_11->name+12)='u';
*(FCNN_2L_W_1out_FB1_22_11->name+13)='t';
*(FCNN_2L_W_1out_FB1_22_11->name+14)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+15)='F';
*(FCNN_2L_W_1out_FB1_22_11->name+16)='B';
*(FCNN_2L_W_1out_FB1_22_11->name+17)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+18)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+19)='2';
*(FCNN_2L_W_1out_FB1_22_11->name+20)='2';
*(FCNN_2L_W_1out_FB1_22_11->name+21)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+22)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+23)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+24)='(';
*(FCNN_2L_W_1out_FB1_22_11->name+25)='F';
*(FCNN_2L_W_1out_FB1_22_11->name+26)='u';
*(FCNN_2L_W_1out_FB1_22_11->name+27)='l';
*(FCNN_2L_W_1out_FB1_22_11->name+28)='l';
*(FCNN_2L_W_1out_FB1_22_11->name+29)='y';
*(FCNN_2L_W_1out_FB1_22_11->name+30)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+31)='C';
*(FCNN_2L_W_1out_FB1_22_11->name+32)='o';
*(FCNN_2L_W_1out_FB1_22_11->name+33)='n';
*(FCNN_2L_W_1out_FB1_22_11->name+34)='n';
*(FCNN_2L_W_1out_FB1_22_11->name+35)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+36)='c';
*(FCNN_2L_W_1out_FB1_22_11->name+37)='t';
*(FCNN_2L_W_1out_FB1_22_11->name+38)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+39)='d';
*(FCNN_2L_W_1out_FB1_22_11->name+40)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+41)='N';
*(FCNN_2L_W_1out_FB1_22_11->name+42)='N';
*(FCNN_2L_W_1out_FB1_22_11->name+43)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+44)='2';
*(FCNN_2L_W_1out_FB1_22_11->name+45)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+46)='L';
*(FCNN_2L_W_1out_FB1_22_11->name+47)='a';
*(FCNN_2L_W_1out_FB1_22_11->name+48)='y';
*(FCNN_2L_W_1out_FB1_22_11->name+49)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+50)='r';
*(FCNN_2L_W_1out_FB1_22_11->name+51)='s';
*(FCNN_2L_W_1out_FB1_22_11->name+52)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+53)='r';
*(FCNN_2L_W_1out_FB1_22_11->name+54)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+55)='c';
*(FCNN_2L_W_1out_FB1_22_11->name+56)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+57)='i';
*(FCNN_2L_W_1out_FB1_22_11->name+58)='v';
*(FCNN_2L_W_1out_FB1_22_11->name+59)='i';
*(FCNN_2L_W_1out_FB1_22_11->name+60)='n';
*(FCNN_2L_W_1out_FB1_22_11->name+61)='g';
*(FCNN_2L_W_1out_FB1_22_11->name+62)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+63)='i';
*(FCNN_2L_W_1out_FB1_22_11->name+64)='n';
*(FCNN_2L_W_1out_FB1_22_11->name+65)='p';
*(FCNN_2L_W_1out_FB1_22_11->name+66)='u';
*(FCNN_2L_W_1out_FB1_22_11->name+67)='t';
*(FCNN_2L_W_1out_FB1_22_11->name+68)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+69)='t';
*(FCNN_2L_W_1out_FB1_22_11->name+70)='h';
*(FCNN_2L_W_1out_FB1_22_11->name+71)='r';
*(FCNN_2L_W_1out_FB1_22_11->name+72)='o';
*(FCNN_2L_W_1out_FB1_22_11->name+73)='u';
*(FCNN_2L_W_1out_FB1_22_11->name+74)='g';
*(FCNN_2L_W_1out_FB1_22_11->name+75)='h';
*(FCNN_2L_W_1out_FB1_22_11->name+76)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+77)='W';
*(FCNN_2L_W_1out_FB1_22_11->name+78)='i';
*(FCNN_2L_W_1out_FB1_22_11->name+79)='n';
*(FCNN_2L_W_1out_FB1_22_11->name+80)='d';
*(FCNN_2L_W_1out_FB1_22_11->name+81)='o';
*(FCNN_2L_W_1out_FB1_22_11->name+82)='w';
*(FCNN_2L_W_1out_FB1_22_11->name+83)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+84)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+85)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+86)='o';
*(FCNN_2L_W_1out_FB1_22_11->name+87)='u';
*(FCNN_2L_W_1out_FB1_22_11->name+88)='t';
*(FCNN_2L_W_1out_FB1_22_11->name+89)='p';
*(FCNN_2L_W_1out_FB1_22_11->name+90)='u';
*(FCNN_2L_W_1out_FB1_22_11->name+91)='t';
*(FCNN_2L_W_1out_FB1_22_11->name+92)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+93)='f';
*(FCNN_2L_W_1out_FB1_22_11->name+94)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+95)='e';
*(FCNN_2L_W_1out_FB1_22_11->name+96)='d';
*(FCNN_2L_W_1out_FB1_22_11->name+97)='b';
*(FCNN_2L_W_1out_FB1_22_11->name+98)='a';
*(FCNN_2L_W_1out_FB1_22_11->name+99)='c';
*(FCNN_2L_W_1out_FB1_22_11->name+100)='k';
*(FCNN_2L_W_1out_FB1_22_11->name+101)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+102)='2';
*(FCNN_2L_W_1out_FB1_22_11->name+103)='>';
*(FCNN_2L_W_1out_FB1_22_11->name+104)='2';
*(FCNN_2L_W_1out_FB1_22_11->name+105)='_';
*(FCNN_2L_W_1out_FB1_22_11->name+106)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+107)='>';
*(FCNN_2L_W_1out_FB1_22_11->name+108)='1';
*(FCNN_2L_W_1out_FB1_22_11->name+109)=')';
*(FCNN_2L_W_1out_FB1_22_11->name+110)=' ';
FCNN_2L_W_1out_FB1_22_11->number_of_Levels=2;
FCNN_2L_W_1out_FB1_22_11->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_22_11->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FB1_22_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_22_11->number_of_Levels);
*(FCNN_2L_W_1out_FB1_22_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_22_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_22_11->recurrence=T;
FCNN_2L_W_1out_FB1_22_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_1out_FB1_22_11->source=MAI((long int)FCNN_2L_W_1out_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22_11->source+0)=2;
*(FCNN_2L_W_1out_FB1_22_11->source+1)=1;
FCNN_2L_W_1out_FB1_22_11->destination=MAI((long int)FCNN_2L_W_1out_FB1_22_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22_11->destination+0)=2;
*(FCNN_2L_W_1out_FB1_22_11->destination+1)=1;
FCNN_2L_W_1out_FB1_22_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_22_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_11->create_neuron==0) exit_handling(102,1);
*(FCNN_2L_W_1out_FB1_22_11->create_neuron+0)=create_FCNN_2L_1out_FB1_22_11;
FCNN_2L_W_1out_FB1_22_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_22_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_22_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_22_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_11->node_linear_output==0) exit_handling(102,2);
*(FCNN_2L_W_1out_FB1_22_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_22_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_22_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_11->node_output==0) exit_handling(102,3);
*(FCNN_2L_W_1out_FB1_22_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_22_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_22_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_22_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_22_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_11->node_output_derivation==0) exit_handling(102,4);
*(FCNN_2L_W_1out_FB1_22_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_22_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_22_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_11->firing_neuron==0) exit_handling(102,5);
*(FCNN_2L_W_1out_FB1_22_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FB1_22_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FB1_22_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_22_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_11->create_learning_algorithm==0) exit_handling(102,6);
*(FCNN_2L_W_1out_FB1_22_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_22_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_22_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_21_11;
FCNN_2L_W_1out_FB1_21_11=MANTD((long int)1);
FCNN_2L_W_1out_FB1_21_11->name=MAC((long int)111);
*(FCNN_2L_W_1out_FB1_21_11->name+0)='F';
*(FCNN_2L_W_1out_FB1_21_11->name+1)='C';
*(FCNN_2L_W_1out_FB1_21_11->name+2)='N';
*(FCNN_2L_W_1out_FB1_21_11->name+3)='N';
*(FCNN_2L_W_1out_FB1_21_11->name+4)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+5)='2';
*(FCNN_2L_W_1out_FB1_21_11->name+6)='L';
*(FCNN_2L_W_1out_FB1_21_11->name+7)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+8)='W';
*(FCNN_2L_W_1out_FB1_21_11->name+9)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+10)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+11)='o';
*(FCNN_2L_W_1out_FB1_21_11->name+12)='u';
*(FCNN_2L_W_1out_FB1_21_11->name+13)='t';
*(FCNN_2L_W_1out_FB1_21_11->name+14)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+15)='F';
*(FCNN_2L_W_1out_FB1_21_11->name+16)='B';
*(FCNN_2L_W_1out_FB1_21_11->name+17)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+18)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+19)='2';
*(FCNN_2L_W_1out_FB1_21_11->name+20)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+21)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+22)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+23)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+24)='(';
*(FCNN_2L_W_1out_FB1_21_11->name+25)='F';
*(FCNN_2L_W_1out_FB1_21_11->name+26)='u';
*(FCNN_2L_W_1out_FB1_21_11->name+27)='l';
*(FCNN_2L_W_1out_FB1_21_11->name+28)='l';
*(FCNN_2L_W_1out_FB1_21_11->name+29)='y';
*(FCNN_2L_W_1out_FB1_21_11->name+30)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+31)='C';
*(FCNN_2L_W_1out_FB1_21_11->name+32)='o';
*(FCNN_2L_W_1out_FB1_21_11->name+33)='n';
*(FCNN_2L_W_1out_FB1_21_11->name+34)='n';
*(FCNN_2L_W_1out_FB1_21_11->name+35)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+36)='c';
*(FCNN_2L_W_1out_FB1_21_11->name+37)='t';
*(FCNN_2L_W_1out_FB1_21_11->name+38)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+39)='d';
*(FCNN_2L_W_1out_FB1_21_11->name+40)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+41)='N';
*(FCNN_2L_W_1out_FB1_21_11->name+42)='N';
*(FCNN_2L_W_1out_FB1_21_11->name+43)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+44)='2';
*(FCNN_2L_W_1out_FB1_21_11->name+45)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+46)='L';
*(FCNN_2L_W_1out_FB1_21_11->name+47)='a';
*(FCNN_2L_W_1out_FB1_21_11->name+48)='y';
*(FCNN_2L_W_1out_FB1_21_11->name+49)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+50)='r';
*(FCNN_2L_W_1out_FB1_21_11->name+51)='s';
*(FCNN_2L_W_1out_FB1_21_11->name+52)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+53)='r';
*(FCNN_2L_W_1out_FB1_21_11->name+54)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+55)='c';
*(FCNN_2L_W_1out_FB1_21_11->name+56)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+57)='i';
*(FCNN_2L_W_1out_FB1_21_11->name+58)='v';
*(FCNN_2L_W_1out_FB1_21_11->name+59)='i';
*(FCNN_2L_W_1out_FB1_21_11->name+60)='n';
*(FCNN_2L_W_1out_FB1_21_11->name+61)='g';
*(FCNN_2L_W_1out_FB1_21_11->name+62)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+63)='i';
*(FCNN_2L_W_1out_FB1_21_11->name+64)='n';
*(FCNN_2L_W_1out_FB1_21_11->name+65)='p';
*(FCNN_2L_W_1out_FB1_21_11->name+66)='u';
*(FCNN_2L_W_1out_FB1_21_11->name+67)='t';
*(FCNN_2L_W_1out_FB1_21_11->name+68)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+69)='t';
*(FCNN_2L_W_1out_FB1_21_11->name+70)='h';
*(FCNN_2L_W_1out_FB1_21_11->name+71)='r';
*(FCNN_2L_W_1out_FB1_21_11->name+72)='o';
*(FCNN_2L_W_1out_FB1_21_11->name+73)='u';
*(FCNN_2L_W_1out_FB1_21_11->name+74)='g';
*(FCNN_2L_W_1out_FB1_21_11->name+75)='h';
*(FCNN_2L_W_1out_FB1_21_11->name+76)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+77)='W';
*(FCNN_2L_W_1out_FB1_21_11->name+78)='i';
*(FCNN_2L_W_1out_FB1_21_11->name+79)='n';
*(FCNN_2L_W_1out_FB1_21_11->name+80)='d';
*(FCNN_2L_W_1out_FB1_21_11->name+81)='o';
*(FCNN_2L_W_1out_FB1_21_11->name+82)='w';
*(FCNN_2L_W_1out_FB1_21_11->name+83)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+84)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+85)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+86)='o';
*(FCNN_2L_W_1out_FB1_21_11->name+87)='u';
*(FCNN_2L_W_1out_FB1_21_11->name+88)='t';
*(FCNN_2L_W_1out_FB1_21_11->name+89)='p';
*(FCNN_2L_W_1out_FB1_21_11->name+90)='u';
*(FCNN_2L_W_1out_FB1_21_11->name+91)='t';
*(FCNN_2L_W_1out_FB1_21_11->name+92)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+93)='f';
*(FCNN_2L_W_1out_FB1_21_11->name+94)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+95)='e';
*(FCNN_2L_W_1out_FB1_21_11->name+96)='d';
*(FCNN_2L_W_1out_FB1_21_11->name+97)='b';
*(FCNN_2L_W_1out_FB1_21_11->name+98)='a';
*(FCNN_2L_W_1out_FB1_21_11->name+99)='c';
*(FCNN_2L_W_1out_FB1_21_11->name+100)='k';
*(FCNN_2L_W_1out_FB1_21_11->name+101)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+102)='2';
*(FCNN_2L_W_1out_FB1_21_11->name+103)='>';
*(FCNN_2L_W_1out_FB1_21_11->name+104)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+105)='_';
*(FCNN_2L_W_1out_FB1_21_11->name+106)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+104)='>';
*(FCNN_2L_W_1out_FB1_21_11->name+108)='1';
*(FCNN_2L_W_1out_FB1_21_11->name+109)=')';
*(FCNN_2L_W_1out_FB1_21_11->name+110)=' ';
FCNN_2L_W_1out_FB1_21_11->number_of_Levels=2;
FCNN_2L_W_1out_FB1_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_21_11->prepare_input()) plus inputs from feedbacks */
FCNN_2L_W_1out_FB1_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_21_11->number_of_Levels);
*(FCNN_2L_W_1out_FB1_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_21_11->recurrence=T;
FCNN_2L_W_1out_FB1_21_11->number_of_recurrent_connected_layers=2;
FCNN_2L_W_1out_FB1_21_11->source=MAI((long int)FCNN_2L_W_1out_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_21_11->source+0)=2;
*(FCNN_2L_W_1out_FB1_21_11->source+1)=1;
FCNN_2L_W_1out_FB1_21_11->destination=MAI((long int)FCNN_2L_W_1out_FB1_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_21_11->destination+0)=1;
*(FCNN_2L_W_1out_FB1_21_11->destination+1)=1;
FCNN_2L_W_1out_FB1_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21_11->create_neuron==0) exit_handling(103,1);
*(FCNN_2L_W_1out_FB1_21_11->create_neuron+0)=create_FCNN_2L_1out_FB1_21_11;
FCNN_2L_W_1out_FB1_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_21_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21_11->node_linear_output==0) exit_handling(103,2);
*(FCNN_2L_W_1out_FB1_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_21_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21_11->node_output==0) exit_handling(103,3);
*(FCNN_2L_W_1out_FB1_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21_11->node_output_derivation==0) exit_handling(103,4);
*(FCNN_2L_W_1out_FB1_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_21_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21_11->firing_neuron==0) exit_handling(103,5);
*(FCNN_2L_W_1out_FB1_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FB1_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FB1_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_21_11->create_learning_algorithm==0) exit_handling(103,6);
*(FCNN_2L_W_1out_FB1_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_21_11);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_22_21 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_21_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_22_21 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_21_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_22_21;
FCNN_2L_W_1out_FB1_22_21=MANTD((long int)1);
FCNN_2L_W_1out_FB1_22_21->name=MAC((long int)111);
*(FCNN_2L_W_1out_FB1_22_21->name+0)='F';
*(FCNN_2L_W_1out_FB1_22_21->name+1)='C';
*(FCNN_2L_W_1out_FB1_22_21->name+2)='N';
*(FCNN_2L_W_1out_FB1_22_21->name+3)='N';
*(FCNN_2L_W_1out_FB1_22_21->name+4)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+5)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+6)='L';
*(FCNN_2L_W_1out_FB1_22_21->name+7)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+8)='W';
*(FCNN_2L_W_1out_FB1_22_21->name+9)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+10)='1';
*(FCNN_2L_W_1out_FB1_22_21->name+11)='o';
*(FCNN_2L_W_1out_FB1_22_21->name+12)='u';
*(FCNN_2L_W_1out_FB1_22_21->name+13)='t';
*(FCNN_2L_W_1out_FB1_22_21->name+14)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+15)='F';
*(FCNN_2L_W_1out_FB1_22_21->name+16)='B';
*(FCNN_2L_W_1out_FB1_22_21->name+17)='1';
*(FCNN_2L_W_1out_FB1_22_21->name+18)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+19)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+20)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+21)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+22)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+23)='1';
*(FCNN_2L_W_1out_FB1_22_21->name+24)='(';
*(FCNN_2L_W_1out_FB1_22_21->name+25)='F';
*(FCNN_2L_W_1out_FB1_22_21->name+26)='u';
*(FCNN_2L_W_1out_FB1_22_21->name+27)='l';
*(FCNN_2L_W_1out_FB1_22_21->name+28)='l';
*(FCNN_2L_W_1out_FB1_22_21->name+29)='y';
*(FCNN_2L_W_1out_FB1_22_21->name+30)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+31)='C';
*(FCNN_2L_W_1out_FB1_22_21->name+32)='o';
*(FCNN_2L_W_1out_FB1_22_21->name+33)='n';
*(FCNN_2L_W_1out_FB1_22_21->name+34)='n';
*(FCNN_2L_W_1out_FB1_22_21->name+35)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+36)='c';
*(FCNN_2L_W_1out_FB1_22_21->name+37)='t';
*(FCNN_2L_W_1out_FB1_22_21->name+38)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+39)='d';
*(FCNN_2L_W_1out_FB1_22_21->name+40)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+41)='N';
*(FCNN_2L_W_1out_FB1_22_21->name+42)='N';
*(FCNN_2L_W_1out_FB1_22_21->name+43)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+44)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+45)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+46)='L';
*(FCNN_2L_W_1out_FB1_22_21->name+47)='a';
*(FCNN_2L_W_1out_FB1_22_21->name+48)='y';
*(FCNN_2L_W_1out_FB1_22_21->name+49)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+50)='r';
*(FCNN_2L_W_1out_FB1_22_21->name+51)='s';
*(FCNN_2L_W_1out_FB1_22_21->name+52)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+53)='r';
*(FCNN_2L_W_1out_FB1_22_21->name+54)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+55)='c';
*(FCNN_2L_W_1out_FB1_22_21->name+56)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+57)='i';
*(FCNN_2L_W_1out_FB1_22_21->name+58)='v';
*(FCNN_2L_W_1out_FB1_22_21->name+59)='i';
*(FCNN_2L_W_1out_FB1_22_21->name+60)='n';
*(FCNN_2L_W_1out_FB1_22_21->name+61)='g';
*(FCNN_2L_W_1out_FB1_22_21->name+62)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+63)='i';
*(FCNN_2L_W_1out_FB1_22_21->name+64)='n';
*(FCNN_2L_W_1out_FB1_22_21->name+65)='p';
*(FCNN_2L_W_1out_FB1_22_21->name+66)='u';
*(FCNN_2L_W_1out_FB1_22_21->name+67)='t';
*(FCNN_2L_W_1out_FB1_22_21->name+68)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+69)='t';
*(FCNN_2L_W_1out_FB1_22_21->name+70)='h';
*(FCNN_2L_W_1out_FB1_22_21->name+71)='r';
*(FCNN_2L_W_1out_FB1_22_21->name+72)='o';
*(FCNN_2L_W_1out_FB1_22_21->name+73)='u';
*(FCNN_2L_W_1out_FB1_22_21->name+74)='g';
*(FCNN_2L_W_1out_FB1_22_21->name+75)='h';
*(FCNN_2L_W_1out_FB1_22_21->name+76)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+77)='W';
*(FCNN_2L_W_1out_FB1_22_21->name+78)='i';
*(FCNN_2L_W_1out_FB1_22_21->name+79)='n';
*(FCNN_2L_W_1out_FB1_22_21->name+80)='d';
*(FCNN_2L_W_1out_FB1_22_21->name+81)='o';
*(FCNN_2L_W_1out_FB1_22_21->name+82)='w';
*(FCNN_2L_W_1out_FB1_22_21->name+83)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+84)='1';
*(FCNN_2L_W_1out_FB1_22_21->name+85)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+86)='o';
*(FCNN_2L_W_1out_FB1_22_21->name+87)='u';
*(FCNN_2L_W_1out_FB1_22_21->name+88)='t';
*(FCNN_2L_W_1out_FB1_22_21->name+89)='p';
*(FCNN_2L_W_1out_FB1_22_21->name+90)='u';
*(FCNN_2L_W_1out_FB1_22_21->name+91)='t';
*(FCNN_2L_W_1out_FB1_22_21->name+92)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+93)='f';
*(FCNN_2L_W_1out_FB1_22_21->name+94)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+95)='e';
*(FCNN_2L_W_1out_FB1_22_21->name+96)='d';
*(FCNN_2L_W_1out_FB1_22_21->name+97)='b';
*(FCNN_2L_W_1out_FB1_22_21->name+98)='a';
*(FCNN_2L_W_1out_FB1_22_21->name+99)='c';
*(FCNN_2L_W_1out_FB1_22_21->name+100)='k';
*(FCNN_2L_W_1out_FB1_22_21->name+101)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+102)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+103)='>';
*(FCNN_2L_W_1out_FB1_22_21->name+104)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+105)='_';
*(FCNN_2L_W_1out_FB1_22_21->name+106)='2';
*(FCNN_2L_W_1out_FB1_22_21->name+107)='>';
*(FCNN_2L_W_1out_FB1_22_21->name+108)='1';
*(FCNN_2L_W_1out_FB1_22_21->name+109)=')';
*(FCNN_2L_W_1out_FB1_22_21->name+110)=' ';
FCNN_2L_W_1out_FB1_22_21->number_of_Levels=2;
FCNN_2L_W_1out_FB1_22_21->inputs_per_first_Level_node=-5+0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_22_21->prepare_input()) plus inputs from feedback */
FCNN_2L_W_1out_FB1_22_21->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_22_21->number_of_Levels);
*(FCNN_2L_W_1out_FB1_22_21->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_22_21->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_22_21->recurrence=T;
FCNN_2L_W_1out_FB1_22_21->number_of_recurrent_connected_layers=2;
FCNN_2L_W_1out_FB1_22_21->source=MAI((long int)FCNN_2L_W_1out_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22_21->source+0)=2;
*(FCNN_2L_W_1out_FB1_22_21->source+1)=2;
FCNN_2L_W_1out_FB1_22_21->destination=MAI((long int)FCNN_2L_W_1out_FB1_22_21->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22_21->destination+0)=2;
*(FCNN_2L_W_1out_FB1_22_21->destination+1)=1;
FCNN_2L_W_1out_FB1_22_21->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_22_21->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21->create_neuron==0) exit_handling(104,1);
*(FCNN_2L_W_1out_FB1_22_21->create_neuron+0)=create_FCNN_2L_1out_FB1_22_21;
FCNN_2L_W_1out_FB1_22_21->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_22_21->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_22_21->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_22_21->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21->node_linear_output==0) exit_handling(104,2);
*(FCNN_2L_W_1out_FB1_22_21->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22_21->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22_21->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_22_21->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_22_21->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21->node_output==0) exit_handling(104,3);
*(FCNN_2L_W_1out_FB1_22_21->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_22_21->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_22_21->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_22_21->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_22_21->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21->node_output_derivation==0) exit_handling(104,4);
*(FCNN_2L_W_1out_FB1_22_21->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_21->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_21->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_21->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_22_21->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_22_21->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21->firing_neuron==0) exit_handling(104,5);
*(FCNN_2L_W_1out_FB1_22_21->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FB1_22_21->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FB1_22_21->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_22_21->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21->create_learning_algorithm==0) exit_handling(104,6);
*(FCNN_2L_W_1out_FB1_22_21->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_22_21->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_22_21);
} /* ; */
/* setting up FCNN_2L_W_1out_FB1_22_21_11 descriptor */
/* neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_21_11_descriptor() sets up neuron_type_descriptor for FCNN_2L_W_1out_FB1_22_21_11 (Fully Connected Neural Network with 2 Layers and input through window function-each of neurones inside neuron population receives input from associated input and its neighborns within distance window radiusand only one output=only one last layer's node and feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) from 2nd layer onto itself and from 2nd layer onto 1st layer and from 1st layer onto itself) class of neurones */
neuron_type_descriptor* setup_FCNN_2L_W_1out_FB1_22_21_11_descriptor()
{
neuron_type_descriptor* FCNN_2L_W_1out_FB1_22_21_11;
FCNN_2L_W_1out_FB1_22_21_11=MANTD((long int)1);
FCNN_2L_W_1out_FB1_22_21_11->name=MAC((long int)118);
*(FCNN_2L_W_1out_FB1_22_21_11->name+0)='F';
*(FCNN_2L_W_1out_FB1_22_21_11->name+1)='C';
*(FCNN_2L_W_1out_FB1_22_21_11->name+2)='N';
*(FCNN_2L_W_1out_FB1_22_21_11->name+3)='N';
*(FCNN_2L_W_1out_FB1_22_21_11->name+4)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+5)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+6)='L';
*(FCNN_2L_W_1out_FB1_22_21_11->name+7)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+8)='W';
*(FCNN_2L_W_1out_FB1_22_21_11->name+9)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+10)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+11)='o';
*(FCNN_2L_W_1out_FB1_22_21_11->name+12)='u';
*(FCNN_2L_W_1out_FB1_22_21_11->name+13)='t';
*(FCNN_2L_W_1out_FB1_22_21_11->name+14)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+15)='F';
*(FCNN_2L_W_1out_FB1_22_21_11->name+16)='B';
*(FCNN_2L_W_1out_FB1_22_21_11->name+17)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+18)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+19)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+20)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+21)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+22)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+23)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+24)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+25)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+26)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+27)='(';
*(FCNN_2L_W_1out_FB1_22_21_11->name+28)='F';
*(FCNN_2L_W_1out_FB1_22_21_11->name+29)='u';
*(FCNN_2L_W_1out_FB1_22_21_11->name+30)='l';
*(FCNN_2L_W_1out_FB1_22_21_11->name+31)='l';
*(FCNN_2L_W_1out_FB1_22_21_11->name+32)='y';
*(FCNN_2L_W_1out_FB1_22_21_11->name+33)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+34)='C';
*(FCNN_2L_W_1out_FB1_22_21_11->name+35)='o';
*(FCNN_2L_W_1out_FB1_22_21_11->name+36)='n';
*(FCNN_2L_W_1out_FB1_22_21_11->name+37)='n';
*(FCNN_2L_W_1out_FB1_22_21_11->name+38)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+39)='c';
*(FCNN_2L_W_1out_FB1_22_21_11->name+40)='t';
*(FCNN_2L_W_1out_FB1_22_21_11->name+41)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+42)='d';
*(FCNN_2L_W_1out_FB1_22_21_11->name+43)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+44)='N';
*(FCNN_2L_W_1out_FB1_22_21_11->name+45)='N';
*(FCNN_2L_W_1out_FB1_22_21_11->name+46)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+47)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+48)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+49)='L';
*(FCNN_2L_W_1out_FB1_22_21_11->name+50)='a';
*(FCNN_2L_W_1out_FB1_22_21_11->name+51)='y';
*(FCNN_2L_W_1out_FB1_22_21_11->name+52)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+53)='r';
*(FCNN_2L_W_1out_FB1_22_21_11->name+54)='s';
*(FCNN_2L_W_1out_FB1_22_21_11->name+55)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+56)='r';
*(FCNN_2L_W_1out_FB1_22_21_11->name+57)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+58)='c';
*(FCNN_2L_W_1out_FB1_22_21_11->name+59)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+60)='i';
*(FCNN_2L_W_1out_FB1_22_21_11->name+61)='v';
*(FCNN_2L_W_1out_FB1_22_21_11->name+62)='i';
*(FCNN_2L_W_1out_FB1_22_21_11->name+63)='n';
*(FCNN_2L_W_1out_FB1_22_21_11->name+64)='g';
*(FCNN_2L_W_1out_FB1_22_21_11->name+65)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+66)='i';
*(FCNN_2L_W_1out_FB1_22_21_11->name+67)='n';
*(FCNN_2L_W_1out_FB1_22_21_11->name+68)='p';
*(FCNN_2L_W_1out_FB1_22_21_11->name+69)='u';
*(FCNN_2L_W_1out_FB1_22_21_11->name+70)='t';
*(FCNN_2L_W_1out_FB1_22_21_11->name+71)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+72)='t';
*(FCNN_2L_W_1out_FB1_22_21_11->name+73)='h';
*(FCNN_2L_W_1out_FB1_22_21_11->name+74)='r';
*(FCNN_2L_W_1out_FB1_22_21_11->name+75)='o';
*(FCNN_2L_W_1out_FB1_22_21_11->name+76)='u';
*(FCNN_2L_W_1out_FB1_22_21_11->name+77)='g';
*(FCNN_2L_W_1out_FB1_22_21_11->name+78)='h';
*(FCNN_2L_W_1out_FB1_22_21_11->name+79)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+80)='W';
*(FCNN_2L_W_1out_FB1_22_21_11->name+81)='i';
*(FCNN_2L_W_1out_FB1_22_21_11->name+82)='n';
*(FCNN_2L_W_1out_FB1_22_21_11->name+83)='d';
*(FCNN_2L_W_1out_FB1_22_21_11->name+84)='o';
*(FCNN_2L_W_1out_FB1_22_21_11->name+85)='w';
*(FCNN_2L_W_1out_FB1_22_21_11->name+86)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+87)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+88)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+89)='o';
*(FCNN_2L_W_1out_FB1_22_21_11->name+90)='u';
*(FCNN_2L_W_1out_FB1_22_21_11->name+91)='t';
*(FCNN_2L_W_1out_FB1_22_21_11->name+92)='p';
*(FCNN_2L_W_1out_FB1_22_21_11->name+93)='u';
*(FCNN_2L_W_1out_FB1_22_21_11->name+94)='t';
*(FCNN_2L_W_1out_FB1_22_21_11->name+95)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+96)='f';
*(FCNN_2L_W_1out_FB1_22_21_11->name+97)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+98)='e';
*(FCNN_2L_W_1out_FB1_22_21_11->name+99)='d';
*(FCNN_2L_W_1out_FB1_22_21_11->name+100)='b';
*(FCNN_2L_W_1out_FB1_22_21_11->name+101)='a';
*(FCNN_2L_W_1out_FB1_22_21_11->name+102)='c';
*(FCNN_2L_W_1out_FB1_22_21_11->name+103)='k';
*(FCNN_2L_W_1out_FB1_22_21_11->name+104)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+105)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+106)='>';
*(FCNN_2L_W_1out_FB1_22_21_11->name+107)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+108)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+109)='2';
*(FCNN_2L_W_1out_FB1_22_21_11->name+110)='>';
*(FCNN_2L_W_1out_FB1_22_21_11->name+111)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+112)='_';
*(FCNN_2L_W_1out_FB1_22_21_11->name+113)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+114)='>';
*(FCNN_2L_W_1out_FB1_22_21_11->name+115)='1';
*(FCNN_2L_W_1out_FB1_22_21_11->name+116)=')';
*(FCNN_2L_W_1out_FB1_22_21_11->name+117)=' ';
FCNN_2L_W_1out_FB1_22_21_11->number_of_Levels=2;
FCNN_2L_W_1out_FB1_22_21_11->inputs_per_first_Level_node=-5+2*0; /* means the input associated with (particular that) neuron (inside neuron_population) and its neighborns (inputs) within distance window_radius (defined with call of FCNN_2L_W_1out_FB1_22_21_11->prepare_input()) plus inputs from feedbacks */
FCNN_2L_W_1out_FB1_22_21_11->nodes_per_Level=MAI((long int)FCNN_2L_W_1out_FB1_22_21_11->number_of_Levels);
*(FCNN_2L_W_1out_FB1_22_21_11->nodes_per_Level+0)=0; /* means there is the same number of nodes in the 1st Level as there are inputs */
*(FCNN_2L_W_1out_FB1_22_21_11->nodes_per_Level+1)=1; /* just one output = just one node in the last layer */
FCNN_2L_W_1out_FB1_22_21_11->recurrence=T;
FCNN_2L_W_1out_FB1_22_21_11->number_of_recurrent_connected_layers=3;
FCNN_2L_W_1out_FB1_22_21_11->source=MAI((long int)FCNN_2L_W_1out_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22_21_11->source+0)=2;
*(FCNN_2L_W_1out_FB1_22_21_11->source+1)=2;
*(FCNN_2L_W_1out_FB1_22_21_11->source+2)=1;
FCNN_2L_W_1out_FB1_22_21_11->destination=MAI((long int)FCNN_2L_W_1out_FB1_22_21_11->number_of_recurrent_connected_layers);
*(FCNN_2L_W_1out_FB1_22_21_11->destination+0)=2;
*(FCNN_2L_W_1out_FB1_22_21_11->destination+1)=1;
*(FCNN_2L_W_1out_FB1_22_21_11->destination+2)=1;
FCNN_2L_W_1out_FB1_22_21_11->number_of_functions_for_creating_neuron=1;
FCNN_2L_W_1out_FB1_22_21_11->create_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21_11->number_of_functions_for_creating_neuron*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21_11->create_neuron==0) exit_handling(105,1);
*(FCNN_2L_W_1out_FB1_22_21_11->create_neuron+0)=create_FCNN_2L_1out_FB1_22_21_11;
FCNN_2L_W_1out_FB1_22_21_11->create_neuron_population=create_neuron_population;
FCNN_2L_W_1out_FB1_22_21_11->prepare_input=preparing_neuron_population_neuron_inputs_through_window;
FCNN_2L_W_1out_FB1_22_21_11->number_linear_output_functions=3;
FCNN_2L_W_1out_FB1_22_21_11->node_linear_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21_11->number_linear_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21_11->node_linear_output==0) exit_handling(105,2);
*(FCNN_2L_W_1out_FB1_22_21_11->node_linear_output+0)=sum_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22_21_11->node_linear_output+1)=product_of_all_weighted_inputs;
*(FCNN_2L_W_1out_FB1_22_21_11->node_linear_output+2)=highest_weighted_input;
FCNN_2L_W_1out_FB1_22_21_11->number_of_node_output_functions=4;
FCNN_2L_W_1out_FB1_22_21_11->node_output=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21_11->node_output==0) exit_handling(105,3);
*(FCNN_2L_W_1out_FB1_22_21_11->node_output+0)=exp_node_output;
*(FCNN_2L_W_1out_FB1_22_21_11->node_output+1)=exp_positive_node_output;
*(FCNN_2L_W_1out_FB1_22_21_11->node_output+2)=treasureholded_node_output;
*(FCNN_2L_W_1out_FB1_22_21_11->node_output+3)=unchanged_linear_node_output;
FCNN_2L_W_1out_FB1_22_21_11->node_output_derivation=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21_11->number_of_node_output_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21_11->node_output_derivation==0) exit_handling(105,4);
*(FCNN_2L_W_1out_FB1_22_21_11->node_output_derivation+0)=exp_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_21_11->node_output_derivation+1)=exp_positive_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_21_11->node_output_derivation+2)=treasureholded_node_output_derivation;
*(FCNN_2L_W_1out_FB1_22_21_11->node_output_derivation+3)=unchanged_linear_node_output_derivation;
FCNN_2L_W_1out_FB1_22_21_11->number_of_firing_functions=2;
FCNN_2L_W_1out_FB1_22_21_11->firing_neuron=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21_11->number_of_firing_functions*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21_11->firing_neuron==0) exit_handling(105,5);
*(FCNN_2L_W_1out_FB1_22_21_11->firing_neuron+0)=firing_feedback_neuron;
*(FCNN_2L_W_1out_FB1_22_21_11->firing_neuron+1)=firing_recurrent_neuron_with_feedback;
FCNN_2L_W_1out_FB1_22_21_11->number_of_learning_algorithms=2;
FCNN_2L_W_1out_FB1_22_21_11->create_learning_algorithm=(void**)testmalloc((size_t)FCNN_2L_W_1out_FB1_22_21_11->number_of_learning_algorithms*sizeof(void*));
if(FCNN_2L_W_1out_FB1_22_21_11->create_learning_algorithm==0) exit_handling(105,6);
*(FCNN_2L_W_1out_FB1_22_21_11->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(FCNN_2L_W_1out_FB1_22_21_11->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
return(FCNN_2L_W_1out_FB1_22_21_11);
} /* ; */
/* Convolutional NNs */
/* setting up convolutional_layer_neuron descriptor */
/* neuron_type_descriptor* setup_convolutional_layer_neuron_descriptor() sets up neuron_type_descriptor for convolutional_layer_neuron class of neurones, used in simulation of CNs (Convolutional NNs) */
/* adviced when input is combined output of other neurones */
/* prepare input function takes whole input fuzzy set as 3D where the 3rd dimension presents different outputs each presenting 2D picture */
/* spatial neighborhood is preserved by taking always all pixel (outputs) with the same 2D coordinate (inside the output pictures of each output) together */
neuron_type_descriptor* setup_convolutional_layer_neuron_descriptor()
{
neuron_type_descriptor* convolutional_layer_neuron;
convolutional_layer_neuron=MANTD((long int)1);
convolutional_layer_neuron->name=MAC((long int)30);
convolutional_layer_neuron->name="convolutional_layer_neuron ";
convolutional_layer_neuron->number_of_Levels=1;
convolutional_layer_neuron->inputs_per_first_Level_node=-6; /* means the input is defined with input window radius (defined with call of convolutional_layer_neuron->prepare_input()) */
convolutional_layer_neuron->nodes_per_Level=MAI((long int)convolutional_layer_neuron->number_of_Levels);
*(convolutional_layer_neuron->nodes_per_Level+0)=1; /* just one node */
convolutional_layer_neuron->recurrence=F;
convolutional_layer_neuron->number_of_recurrent_connected_layers=0;
convolutional_layer_neuron->source=0;
convolutional_layer_neuron->destination=0;
convolutional_layer_neuron->number_of_functions_for_creating_neuron=1;
convolutional_layer_neuron->create_neuron=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_functions_for_creating_neuron*sizeof(void*));
if(convolutional_layer_neuron->create_neuron==0) exit_handling(1003,1);
*(convolutional_layer_neuron->create_neuron+0)=create_FCNN_1L_1out;
convolutional_layer_neuron->create_neuron_population=create_neuron_population; /* vertical_resolution should be replaced with overlaping_radius presenting number of pixels overlaping in each dimension (for example if overlaping_radius means overlaping with each neighbor (left, right, upper, lower) with 2 pixels) */
convolutional_layer_neuron->create_neuron_population_from_nucleotide_base=create_convolutional_layer_neuron_population_from_nucleotide_base; /* inside nucleotide base's handling_input dimensions should be stored first horisontal_dimension, and then vertical_dimension */
convolutional_layer_neuron->prepare_input=preparing_neuron_population_input_by_preserving_spatial_neighborhood_for_convolutional_layer_neuron;
convolutional_layer_neuron->number_linear_output_functions=4;
convolutional_layer_neuron->node_linear_output=(void**)testmalloc((size_t)convolutional_layer_neuron->number_linear_output_functions*sizeof(void*));
if(convolutional_layer_neuron->node_linear_output==0) exit_handling(1003,2);
*(convolutional_layer_neuron->node_linear_output+0)=sum_of_all_weighted_inputs;
*(convolutional_layer_neuron->node_linear_output+1)=product_of_all_weighted_inputs;
*(convolutional_layer_neuron->node_linear_output+2)=highest_weighted_input;
*(convolutional_layer_neuron->node_linear_output+3)=RBF_exp;
convolutional_layer_neuron->number_of_node_output_functions=5;
convolutional_layer_neuron->node_output=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_node_output_functions*sizeof(void*));
if(convolutional_layer_neuron->node_output==0) exit_handling(1003,3);
*(convolutional_layer_neuron->node_output+0)=exp_node_output;
*(convolutional_layer_neuron->node_output+1)=exp_positive_node_output;
*(convolutional_layer_neuron->node_output+2)=tgh_node_output;
*(convolutional_layer_neuron->node_output+3)=treasureholded_node_output;
*(convolutional_layer_neuron->node_output+4)=unchanged_linear_node_output;
convolutional_layer_neuron->node_output_derivation=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_node_output_functions*sizeof(void*));
if(convolutional_layer_neuron->node_output_derivation==0) exit_handling(1003,4);
*(convolutional_layer_neuron->node_output_derivation+0)=exp_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+1)=exp_positive_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+2)=tgh_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+3)=treasureholded_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+4)=unchanged_linear_node_output_derivation;
convolutional_layer_neuron->number_of_firing_functions=1;
convolutional_layer_neuron->firing_neuron=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_firing_functions*sizeof(void*));
if(convolutional_layer_neuron->firing_neuron==0) exit_handling(1003,5);
*(convolutional_layer_neuron->firing_neuron)=firing_standard_neuron;
convolutional_layer_neuron->number_of_learning_algorithms=3;
convolutional_layer_neuron->create_learning_algorithm=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_learning_algorithms*sizeof(void*));
if(convolutional_layer_neuron->create_learning_algorithm==0) exit_handling(1003,6);
*(convolutional_layer_neuron->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(convolutional_layer_neuron->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(convolutional_layer_neuron->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(convolutional_layer_neuron);
} /* ; */
/* neuron_type_descriptor* setup_convolutional_layer_neuron_descriptor1() sets up neuron_type_descriptor for convolutional_layer_neuron class of neurones, used in simulation of CNs (Convolutional NNs) similar to convolutional_layer_neuron_descriptor just with another function for preparing input */
/* adviced when input is the original picture */
/* prepare input function takes whole input fuzzy set as one big 2D picture */
neuron_type_descriptor* setup_convolutional_layer_neuron_descriptor1()
{
neuron_type_descriptor* convolutional_layer_neuron;
convolutional_layer_neuron=MANTD((long int)1);
convolutional_layer_neuron->name=MAC((long int)31);
convolutional_layer_neuron->name="convolutional_layer_neuron1 ";
convolutional_layer_neuron->number_of_Levels=1;
convolutional_layer_neuron->inputs_per_first_Level_node=-6; /* means the input is defined with input window radius (defined with call of convolutional_layer_neuron->prepare_input()) */
convolutional_layer_neuron->nodes_per_Level=MAI((long int)convolutional_layer_neuron->number_of_Levels);
*(convolutional_layer_neuron->nodes_per_Level+0)=1; /* just one node */
convolutional_layer_neuron->recurrence=F;
convolutional_layer_neuron->number_of_recurrent_connected_layers=0;
convolutional_layer_neuron->source=0;
convolutional_layer_neuron->destination=0;
convolutional_layer_neuron->number_of_functions_for_creating_neuron=1;
convolutional_layer_neuron->create_neuron=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_functions_for_creating_neuron*sizeof(void*));
if(convolutional_layer_neuron->create_neuron==0) exit_handling(1003,7);
*(convolutional_layer_neuron->create_neuron+0)=create_FCNN_1L_1out;
convolutional_layer_neuron->create_neuron_population=create_neuron_population; /* vertical_resolution should be replaced with overlaping_radius presenting number of pixels overlaping in each dimension (for example if overlaping_radius means overlaping with each neighbor (left, right, upper, lower) with 2 pixels) */
convolutional_layer_neuron->create_neuron_population_from_nucleotide_base=create_convolutional_layer_neuron_population_from_nucleotide_base; /* inside nucleotide base's handling_input dimensions should be stored first horisontal_dimension, and then vertical_dimension */
convolutional_layer_neuron->prepare_input=preparing_neuron_population_input_for_convolutional_layer_neuron;
convolutional_layer_neuron->number_linear_output_functions=4;
convolutional_layer_neuron->node_linear_output=(void**)testmalloc((size_t)convolutional_layer_neuron->number_linear_output_functions*sizeof(void*));
if(convolutional_layer_neuron->node_linear_output==0) exit_handling(1003,8);
*(convolutional_layer_neuron->node_linear_output+0)=sum_of_all_weighted_inputs;
*(convolutional_layer_neuron->node_linear_output+1)=product_of_all_weighted_inputs;
*(convolutional_layer_neuron->node_linear_output+2)=highest_weighted_input;
*(convolutional_layer_neuron->node_linear_output+3)=RBF_exp;
convolutional_layer_neuron->number_of_node_output_functions=5;
convolutional_layer_neuron->node_output=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_node_output_functions*sizeof(void*));
if(convolutional_layer_neuron->node_output==0) exit_handling(1003,9);
*(convolutional_layer_neuron->node_output+0)=exp_node_output;
*(convolutional_layer_neuron->node_output+1)=exp_positive_node_output;
*(convolutional_layer_neuron->node_output+2)=tgh_node_output;
*(convolutional_layer_neuron->node_output+3)=treasureholded_node_output;
*(convolutional_layer_neuron->node_output+4)=unchanged_linear_node_output;
convolutional_layer_neuron->node_output_derivation=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_node_output_functions*sizeof(void*));
if(convolutional_layer_neuron->node_output_derivation==0) exit_handling(1003,10);
*(convolutional_layer_neuron->node_output_derivation+0)=exp_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+1)=exp_positive_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+2)=tgh_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+3)=treasureholded_node_output_derivation;
*(convolutional_layer_neuron->node_output_derivation+4)=unchanged_linear_node_output_derivation;
convolutional_layer_neuron->number_of_firing_functions=1;
convolutional_layer_neuron->firing_neuron=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_firing_functions*sizeof(void*));
if(convolutional_layer_neuron->firing_neuron==0) exit_handling(1003,11);
*(convolutional_layer_neuron->firing_neuron)=firing_standard_neuron;
convolutional_layer_neuron->number_of_learning_algorithms=3;
convolutional_layer_neuron->create_learning_algorithm=(void**)testmalloc((size_t)convolutional_layer_neuron->number_of_learning_algorithms*sizeof(void*));
if(convolutional_layer_neuron->create_learning_algorithm==0) exit_handling(1003,12);
*(convolutional_layer_neuron->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(convolutional_layer_neuron->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(convolutional_layer_neuron->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
return(convolutional_layer_neuron);
} /* ; */
/* setting up averaging_layer_neuron descriptor */
/* neuron_type_descriptor* setup_averaging_layer_neuron_descriptor() sets up neuron_type_descriptor for averaging_layer_neuron class of neurones, used in simulation of CNs (Convolutional NNs) */
neuron_type_descriptor* setup_averaging_layer_neuron_descriptor()
{
neuron_type_descriptor* averaging_layer_neuron;
averaging_layer_neuron=MANTD((long int)1);
averaging_layer_neuron->name=MAC((long int)26);
averaging_layer_neuron->name="averaging_layer_neuron ";
averaging_layer_neuron->number_of_Levels=1;
averaging_layer_neuron->inputs_per_first_Level_node=-6; /* means the input is defined with input window radius (defined with call of averaging_layer_neuron->prepare_input()) */
averaging_layer_neuron->nodes_per_Level=MAI((long int)averaging_layer_neuron->number_of_Levels);
*(averaging_layer_neuron->nodes_per_Level+0)=1; /* just one node */
averaging_layer_neuron->recurrence=F;
averaging_layer_neuron->number_of_recurrent_connected_layers=0;
averaging_layer_neuron->source=0;
averaging_layer_neuron->destination=0;
averaging_layer_neuron->number_of_functions_for_creating_neuron=2;
averaging_layer_neuron->create_neuron=(void**)testmalloc((size_t)averaging_layer_neuron->number_of_functions_for_creating_neuron*sizeof(void*));
if(averaging_layer_neuron->create_neuron==0) exit_handling(1004,1);
*(averaging_layer_neuron->create_neuron+0)=create_FCNN_1L_1out;
*(averaging_layer_neuron->create_neuron+1)=create_FCNN_1L_1out_fixed_weights;
averaging_layer_neuron->create_neuron_population=create_neuron_population; /* vertical_resolution should be replaced with overlaping_radius presenting number of pixels overlaping in each dimension (for example if overlaping_radius means overlaping with each neighbor (left, right, upper, lower) with 2 pixels) */
averaging_layer_neuron->create_neuron_population_from_nucleotide_base=create_convolutional_layer_neuron_population_from_nucleotide_base; /* this function suits also for averaging layer neuron populations */
averaging_layer_neuron->prepare_input=preparing_neuron_population_input_for_convolutional_layer_neuron;
averaging_layer_neuron->number_linear_output_functions=4;
averaging_layer_neuron->node_linear_output=(void**)testmalloc((size_t)averaging_layer_neuron->number_linear_output_functions*sizeof(void*));
if(averaging_layer_neuron->node_linear_output==0) exit_handling(1004,2);
*(averaging_layer_neuron->node_linear_output+0)=sum_of_all_weighted_inputs;
*(averaging_layer_neuron->node_linear_output+1)=product_of_all_weighted_inputs;
*(averaging_layer_neuron->node_linear_output+2)=highest_weighted_input;
*(averaging_layer_neuron->node_linear_output+3)=RBF_exp;
averaging_layer_neuron->number_of_node_output_functions=5;
averaging_layer_neuron->node_output=(void**)testmalloc((size_t)averaging_layer_neuron->number_of_node_output_functions*sizeof(void*));
if(averaging_layer_neuron->node_output==0) exit_handling(1004,3);
*(averaging_layer_neuron->node_output+0)=exp_node_output;
*(averaging_layer_neuron->node_output+1)=exp_positive_node_output;
*(averaging_layer_neuron->node_output+2)=tgh_node_output;
*(averaging_layer_neuron->node_output+3)=treasureholded_node_output;
*(averaging_layer_neuron->node_output+4)=unchanged_linear_node_output;
averaging_layer_neuron->node_output_derivation=(void**)testmalloc((size_t)averaging_layer_neuron->number_of_node_output_functions*sizeof(void*));
if(averaging_layer_neuron->node_output_derivation==0) exit_handling(1004,4);
*(averaging_layer_neuron->node_output_derivation+0)=exp_node_output_derivation;
*(averaging_layer_neuron->node_output_derivation+1)=exp_positive_node_output_derivation;
*(averaging_layer_neuron->node_output_derivation+2)=tgh_node_output_derivation;
*(averaging_layer_neuron->node_output_derivation+3)=treasureholded_node_output_derivation;
*(averaging_layer_neuron->node_output_derivation+4)=unchanged_linear_node_output_derivation;
averaging_layer_neuron->number_of_firing_functions=1;
averaging_layer_neuron->firing_neuron=(void**)testmalloc((size_t)averaging_layer_neuron->number_of_firing_functions*sizeof(void*));
if(averaging_layer_neuron->firing_neuron==0) exit_handling(1004,5);
*(averaging_layer_neuron->firing_neuron+0)=firing_standard_neuron;
averaging_layer_neuron->number_of_learning_algorithms=5;
averaging_layer_neuron->create_learning_algorithm=(void**)testmalloc((size_t)averaging_layer_neuron->number_of_learning_algorithms*sizeof(void*));
if(averaging_layer_neuron->create_learning_algorithm==0) exit_handling(1004,6);
*(averaging_layer_neuron->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(averaging_layer_neuron->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(averaging_layer_neuron->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
*(averaging_layer_neuron->create_learning_algorithm+3)=BP_without_learning_algorithm_setup;
*(averaging_layer_neuron->create_learning_algorithm+4)=no_learning_neuron_learning_algorithm_setup;
return(averaging_layer_neuron);
} /* ; */
/* setting up simple_neuron descriptor */
/* neuron_type_descriptor* setup_simple_neuron_descriptor() sets up neuron_type_descriptor for simple_neuron class of neurones, used in simulation of CNs (Convolutional NNs) */
neuron_type_descriptor* setup_simple_neuron_descriptor()
{
neuron_type_descriptor* simple_neuron;
simple_neuron=MANTD((long int)1);
simple_neuron->name=MAC((long int)17);
simple_neuron->name="simple_neuron ";
simple_neuron->number_of_Levels=1;
simple_neuron->inputs_per_first_Level_node=0; /* means all inputs are associated with all 1st Level nodes */
simple_neuron->nodes_per_Level=MAI((long int)simple_neuron->number_of_Levels);
*(simple_neuron->nodes_per_Level+0)=1; /* just one node */
simple_neuron->recurrence=F;
simple_neuron->number_of_recurrent_connected_layers=0;
simple_neuron->source=0;
simple_neuron->destination=0;
simple_neuron->number_of_functions_for_creating_neuron=2;
simple_neuron->create_neuron=(void**)testmalloc((size_t)simple_neuron->number_of_functions_for_creating_neuron*sizeof(void*));
if(simple_neuron->create_neuron==0) exit_handling(106,1);
*(simple_neuron->create_neuron+0)=create_FCNN_1L_1out;
*(simple_neuron->create_neuron+1)=create_FCNN_1L_1out_fixed_weights;
simple_neuron->create_neuron_population=create_neuron_population; /* vertical_resolution should be replaced with overlaping_radius presenting number of pixels overlaping in each dimension (for example if overlaping_radius means overlaping with each neighbor (left, right, upper, lower) with 2 pixels) */
simple_neuron->create_neuron_population_from_nucleotide_base=create_convolutional_layer_neuron_population_from_nucleotide_base; /* this function is porposed for neuron populations whose neurones overlapping their input (fields). Therefore nucleotide_base's elements: handling_input, overlaping_in_each_dimension, and window_side_lenght must be filled overlaping_in_each_dimension=0, while handling_input(vector dimensions) and window side_lenght must be combined that window_side_lenght is greater or equal to each dimension inside handling_input. */
simple_neuron->prepare_input=0;
simple_neuron->number_linear_output_functions=7;
simple_neuron->node_linear_output=(void**)testmalloc((size_t)simple_neuron->number_linear_output_functions*sizeof(void*));
if(simple_neuron->node_linear_output==0) exit_handling(106,2);
*(simple_neuron->node_linear_output+0)=sum_of_all_weighted_inputs;
*(simple_neuron->node_linear_output+1)=product_of_all_weighted_inputs;
*(simple_neuron->node_linear_output+2)=highest_weighted_input;
*(simple_neuron->node_linear_output+3)=RBF_exp;
*(simple_neuron->node_linear_output+4)=entropy_Reyni;
*(simple_neuron->node_linear_output+5)=entropy_Deluce_Termini;
*(simple_neuron->node_linear_output+6)=sum_of_all_times_exponent_of_last_weighted_inputs;
simple_neuron->number_of_node_output_functions=5;
simple_neuron->node_output=(void**)testmalloc((size_t)simple_neuron->number_of_node_output_functions*sizeof(void*));
if(simple_neuron->node_output==0) exit_handling(106,3);
*(simple_neuron->node_output+0)=exp_node_output;
*(simple_neuron->node_output+1)=exp_positive_node_output;
*(simple_neuron->node_output+2)=tgh_node_output;
*(simple_neuron->node_output+3)=treasureholded_node_output;
*(simple_neuron->node_output+4)=unchanged_linear_node_output;
simple_neuron->node_output_derivation=(void**)testmalloc((size_t)simple_neuron->number_of_node_output_functions*sizeof(void*));
if(simple_neuron->node_output_derivation==0) exit_handling(106,4);
*(simple_neuron->node_output_derivation+0)=exp_node_output_derivation;
*(simple_neuron->node_output_derivation+1)=exp_positive_node_output_derivation;
*(simple_neuron->node_output_derivation+2)=tgh_node_output_derivation;
*(simple_neuron->node_output_derivation+3)=treasureholded_node_output_derivation;
*(simple_neuron->node_output_derivation+4)=unchanged_linear_node_output_derivation;
simple_neuron->number_of_firing_functions=1;
simple_neuron->firing_neuron=(void**)testmalloc((size_t)simple_neuron->number_of_firing_functions*sizeof(void*));
if(simple_neuron->firing_neuron==0) exit_handling(106,5);
*(simple_neuron->firing_neuron+0)=firing_standard_neuron;
simple_neuron->number_of_learning_algorithms=8;
simple_neuron->create_learning_algorithm=(void**)testmalloc((size_t)simple_neuron->number_of_learning_algorithms*sizeof(void*));
if(simple_neuron->create_learning_algorithm==0) exit_handling(106,6);
*(simple_neuron->create_learning_algorithm+0)=BP_neuron_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+1)=weight_shaking_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+2)=BP_RBF_exp_neuron_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+3)=BP_entropy_Deluce_Termini_neuron_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+4)=BP_entropy_Reyni_neuron_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+5)=BP_without_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+6)=no_learning_neuron_learning_algorithm_setup;
*(simple_neuron->create_learning_algorithm+7)=BP_sum_of_all_times_exponent_of_last_weighted_inputs_neuron_learning_algorithm_setup;
return(simple_neuron);
} /* ; */
/* common functions for almost all types of neurones */
void *creating_neuron_population_output(neuron_population *np)
/* creates neuron population's output fuzzy set whose fuzzy objects are neuron population's neurones' output fuzzy objects in the same order as neurones inside neuron population */
{
int i;
np->output=MAFS((long int)1);
np->output->name=MAC((long int)7);
*(np->output->name+0)='O';
*(np->output->name+1)='U';
*(np->output->name+2)='T';
*(np->output->name+3)='P';
*(np->output->name+4)='U';
*(np->output->name+5)='T';
*(np->output->name+6)=' ';
np->output->number_of_objects=np->number_of_neurones;
np->output->objects=MApFO((long int)np->output->number_of_objects);
for(i=0; ioutput->number_of_objects; i++)
*(np->output->objects+i)=(*(np->neurones))->output;
} /* ; */
enum Bool setup_weights_pointers(Level* actual_Level, Level *previous_Level)
/* fill pointers of actual_level's nodes' characteristics (weights) toward previous_Level's nodes. Characteristics (weights) of each actual_Level's node points toward each of previous_Level's nodes (it means each actual_Level's node consists pointers toward all previous_Level nodes). In the case any actual_Level's node has different number of characteristics (weights) than previous_Level has nodes F=0 is returned. Otherwise T=1 i returned. */
{
enum Bool check=T;
int i,j;
for(j=0; jnumber_of_nodes; j++)
{
for(i=0, (*(actual_Level->nodes+j))->actual=(*(actual_Level->nodes+j))->first; (inumber_of_nodes)&&((*(actual_Level->nodes+j))->actual!=0); i++, (*(actual_Level->nodes+j))->actual=(*(actual_Level->nodes+j))->actual->follow)
(*(actual_Level->nodes+j))->actual->set=*(previous_Level->nodes+i);
if(((*(actual_Level->nodes+j))->actual!=0)||(i!=previous_Level->number_of_nodes)) check=F;
};
return(check);
} /* ; */
float even_minus_odd(fuzzy_object *node, int Level_number)
/* Sum of weighted odd inputs is substracted from sum of weighted even inputs. 0 is taken as even number! first_characteristic points on 0 input, first_characteristic->follow points on 1st input etc. */
{
float sum=0.0;
int i;
if(Level_number==1)
for(node->actual=node->first, i=0; node->actual!=0; i++, node->actual=node->actual->follow)
sum+=(float)pow((double)-1,(double)i)*((*((float*)(node->actual->set))))*node->actual->membership;
else
for(node->actual=node->first, i=0; node->actual!=0; i++, node->actual=node->actual->follow)
sum+=(float)pow((double)-1,(double)i)*node->actual->set->m.notes*node->actual->membership;
return(sum);
} /* ; */
float Max_output_node(fuzzy_object *node)
/* calculate Maximum of all weighted inputs into the node and DOESN'T WRITE into node's m.notes */
{
register float weighted_input, Max=-10.0;
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
{
weighted_input=node->actual->set->m.notes*node->actual->membership;
if(weighted_input>Max) Max=weighted_input;
};
return(Max);
} /* ; */
float exp_node_output(float linear_output)
/* node's output is non-linearised using exponential function y(x)=-1+1/(1+e^(-node_output_e_exponent*x)); where node_output_e_exponent is declared as extern and preset on 5.0. Output is also filtered with treasurehold set up over common/extern variable "treasureholdadd". */
/* THRESHOLD MUSN'T BE FORGOTEN TO BE SETUP as outputs are between -1 and 1 so threshold should be -1.0 */
{
extern char node_output_type;
node_output_type='E';
return(node_output(linear_output));
} /* ; */
float exp_node_output_derivation(float value)
/* output is the first derivation of exp_node_output() function for the given value */
{
extern char node_output_type;
node_output_type='E';
return(node_output_derivation(value));
} /* ; */
float exp_positive_node_output(float linear_output)
/* node's output is non-linearised using exponential function y(x)=1/(1+e^(-node_output_e_exponent*x)). Output is also filtered with treasurehold set up over common/extern variable "treasureholdadd". */
{
extern char node_output_type;
node_output_type='e';
return(node_output(linear_output));
} /* ; */
float exp_positive_node_output_derivation(float value)
/* output is the first derivation of exp_node_output() function for the given value */
{
extern char node_output_type;
node_output_type='e';
return(node_output_derivation(value));
} /* ; */
float tgh_node_output(float linear_output)
/* node's output is non-linearised using tanges hiperbolic function y(x)=(tgh(2*x*PI-PI)+1)/2. Output is also filtered with treasurehold set up over common/extern variable "treasureholdadd". */
{
extern char node_output_type;
node_output_type='t';
return(node_output(linear_output));
} /* ; */
float tgh_node_output_derivation(float value)
/* output is the first derivation of tgh_node_output() function for the given value */
{
extern char node_output_type;
node_output_type='t';
return(node_output_derivation(value));
} /* ; */
float treasureholded_node_output(float linear_output)
/* node's output is non-linearised through filtering with treasurehold set up over common/extern variable "treasureholdadd". */
{
extern char node_output_type;
node_output_type='l';
return(node_output(linear_output));
} /* ; */
float treasureholded_node_output_derivation(float value)
/* output is the first derivation of treasureholded_node_output() function for the given value */
{
extern char node_output_type;
node_output_type='l';
return(node_output_derivation(value));
} /* ; */
float unchanged_linear_node_output(float linear_output)
/* output is unchanged linear node output */
{
/* return((linear_output>1.0)?1.0:(linear_output<0.0)?0.00001:linear_output); */
return(linear_output);
} /* ; */
float unchanged_linear_node_output_derivation(float value)
/* output is the first derivation of unchanged_linear_node_output() function for the given value */
{
return(1.0);
} /* ; */
neuron *create_FCNN_1L_1out(fuzzy_set *input)
/* create the neuron of FCNN with only 1 layer and only 1 characteristic in the output fuzzy object type. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to one node). Output fuzzy object consists just one characteristics as there are nodes in the first and only Level. */
{
neuron *head;
int i,j;
/*float *weights;
enum Bool check;*/
head=MAN((long int)1);
head->name=0;
head->number_of_Levels=1;
/* creation of the first Level */
head->first_Level=MALe((long int)1);
head->actual_Level=head->first_Level;
head->last_Level=head->first_Level;
head->first_Level->follow=0;
head->first_Level->ahead=0;
head->first_Level->number_of_nodes=1;
head->first_Level->Level_number=1;
head->first_Level->nodes=MApFO((long int)head->first_Level->number_of_nodes);
*(head->first_Level->nodes+0)=MAFO((long int)1);
(*(head->first_Level->nodes+0))->m.notes=0.0;
(*(head->first_Level->nodes+0))->actual=0;
(*(head->first_Level->nodes+0))->first=0;
for(i=0, (*(head->first_Level->nodes+0))->number_of_characteristics=0; inumber_of_objects; i++)
(*(head->first_Level->nodes+0))->number_of_characteristics+=(*(input->objects+i))->number_of_characteristics;
for(j=0; jnumber_of_objects; j++)
for((*(input->objects+j))->actual=(*(input->objects+j))->first; (*(input->objects+j))->actual!=0;(*(input->objects+j))->actual=(*(input->objects+j))->actual->follow)
{
(*(head->first_Level->nodes+0))->last=MACl((long int)1);
if((*(head->first_Level->nodes+0))->first==0) (*(head->first_Level->nodes+0))->first=(*(head->first_Level->nodes+0))->last;
(*(head->first_Level->nodes+0))->last->name=0;
(*(head->first_Level->nodes+0))->last->membership=1.0;
(*(head->first_Level->nodes+0))->last->set=(fuzzy_object*)(&((*(input->objects+j))->actual->membership));
(*(head->first_Level->nodes+0))->last->follow=0;
(*(head->first_Level->nodes+0))->last->ahead=(*(head->first_Level->nodes+0))->actual;
if((*(head->first_Level->nodes+0))->actual!=0) (*(head->first_Level->nodes+0))->actual->follow=(*(head->first_Level->nodes+0))->last;
(*(head->first_Level->nodes+0))->actual=(*(head->first_Level->nodes+0))->last;
};
/* checking if BIAS_fuzzy_object is already allocated, and allocating it if not */
if(BIAS_fuzzy_object==NULL)
{
BIAS_fuzzy_object=MAFO((long int)1);
BIAS_fuzzy_object->m.notes=(float)BIAS;
BIAS_fuzzy_object->first=0;
BIAS_fuzzy_object->actual=0;
BIAS_fuzzy_object->last=0;
BIAS_fuzzy_object->number_of_characteristics=0;
};
/* adding BIAS input */
(*(head->first_Level->nodes+0))->actual=(*(head->first_Level->nodes+0))->last;
(*(head->first_Level->nodes+0))->last=MACl((long int)1);
(*(head->first_Level->nodes+0))->last->name=MAC((long int)sizeof("BIAS"));
sprintf((*(head->first_Level->nodes+0))->last->name, "BIAS");
(*(head->first_Level->nodes+0))->last->membership=1.0;
(*(head->first_Level->nodes+0))->last->set=(fuzzy_object*)(&(BIAS_fuzzy_object->m.notes));
(*(head->first_Level->nodes+0))->last->follow=0;
(*(head->first_Level->nodes+0))->last->ahead=(*(head->first_Level->nodes+0))->actual;
if((*(head->first_Level->nodes+0))->actual!=0) (*(head->first_Level->nodes+0))->actual->follow=(*(head->first_Level->nodes+0))->last;
(*(head->first_Level->nodes+0))->number_of_characteristics++;
/* creation of output */
head->output=MAFO((long int)1);
head->output->m.name=MAC((long int)7);
*(head->output->m.name+0)='O';
*(head->output->m.name+1)='U';
*(head->output->m.name+2)='T';
*(head->output->m.name+3)='P';
*(head->output->m.name+4)='U';
*(head->output->m.name+5)='T';
*(head->output->m.name+6)=' ';
head->output->number_of_characteristics=head->last_Level->number_of_nodes;
head->output->first=0;
head->output->actual=0;
for(i=0; ioutput->number_of_characteristics; i++)
{
head->output->last=MACl((long int)1);
if(head->output->first==0) head->output->first=head->output->last;
head->output->last->name=0;
head->output->last->membership=0.0;
head->output->last->set=*(head->last_Level->nodes+i);
head->output->last->ahead=head->output->actual;
head->output->last->follow=0;
if(head->output->actual!=0) head->output->actual->follow=head->output->last;
head->output->actual=head->output->last;
};
filling_weights_with_randum_numbers(head);
return(head);
} /* ; */
neuron *create_FCNN(fuzzy_set *input, int number_of_Levels)
/* create the neuron of FCNN type with given number of layers. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to all nodes). The each successive Level nodes are receving inputs each from all nodes of the preceded Level. Output fuzzy object consists as many characteristics as there are nodes in the last Level (= number of nodes in each Level = number of input fuzzy set objects' characteristics). */
{
neuron *head;
int i,j,k;
/*float *weights;
enum Bool check;*/
head=MAN((long int)1);
head->name=0;
head->number_of_Levels=number_of_Levels;
/* creation of the first Level */
head->first_Level=MALe((long int)1);
head->actual_Level=head->first_Level;
head->last_Level=head->first_Level;
head->first_Level->follow=0;
head->first_Level->ahead=0;
/* checking if BIAS_fuzzy_object is already allocated, and allocating it if not */
if(BIAS_fuzzy_object==NULL)
{
BIAS_fuzzy_object=MAFO((long int)1);
BIAS_fuzzy_object->m.notes=(float)BIAS;
BIAS_fuzzy_object->first=0;
BIAS_fuzzy_object->actual=0;
BIAS_fuzzy_object->last=0;
BIAS_fuzzy_object->number_of_characteristics=0;
};
for(i=0, head->first_Level->number_of_nodes=0; inumber_of_objects; i++)
head->first_Level->number_of_nodes+=(*(input->objects+i))->number_of_characteristics;
head->first_Level->Level_number=1;
head->first_Level->nodes=MApFO((long int)head->first_Level->number_of_nodes);
for(i=0; ifirst_Level->number_of_nodes; i++)
{
*(head->first_Level->nodes+i)=MAFO((long int)1);
(*(head->first_Level->nodes+i))->number_of_characteristics=head->first_Level->number_of_nodes;
(*(head->first_Level->nodes+i))->m.notes=0.0;
(*(head->first_Level->nodes+i))->actual=0;
(*(head->first_Level->nodes+i))->first=0;
for(j=0, k=0; jnumber_of_objects; j++)
for((*(input->objects+j))->actual=(*(input->objects+j))->first; (*(input->objects+j))->actual!=0;(*(input->objects+j))->actual=(*(input->objects+j))->actual->follow, k++)
{
(*(head->first_Level->nodes+i))->last=MACl((long int)1);
if((*(head->first_Level->nodes+i))->first==0) (*(head->first_Level->nodes+i))->first=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->last->name=0;
(*(head->first_Level->nodes+i))->last->membership=1.0;
(*(head->first_Level->nodes+i))->last->set=(fuzzy_object*)(&((*(input->objects+j))->actual->membership));
(*(head->first_Level->nodes+i))->last->follow=0;
(*(head->first_Level->nodes+i))->last->ahead=(*(head->first_Level->nodes+i))->actual;
if((*(head->first_Level->nodes+i))->actual!=0) (*(head->first_Level->nodes+i))->actual->follow=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->actual=(*(head->first_Level->nodes+i))->last;
};
/* adding BIAS input */
(*(head->first_Level->nodes+i))->actual=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->last=MACl((long int)1);
(*(head->first_Level->nodes+i))->last->name=MAC((long int)sizeof("BIAS"));
sprintf((*(head->first_Level->nodes+i))->last->name, "BIAS");
(*(head->first_Level->nodes+i))->last->membership=1.0;
(*(head->first_Level->nodes+i))->last->set=(fuzzy_object*)(&(BIAS_fuzzy_object->m.notes));
(*(head->first_Level->nodes+i))->last->follow=0;
(*(head->first_Level->nodes+i))->last->ahead=(*(head->first_Level->nodes+i))->actual;
if((*(head->first_Level->nodes+i))->actual!=0) (*(head->first_Level->nodes+i))->actual->follow=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->number_of_characteristics++;
};
/* creation of remained Levels */
for(j=2; jnumber_of_Levels+1; j++)
{
head->last_Level=MALe((long int)1);
head->actual_Level->follow=head->last_Level;
head->last_Level->ahead=head->actual_Level;
head->actual_Level=head->last_Level;
head->last_Level->number_of_nodes=head->last_Level->ahead->number_of_nodes;
head->last_Level->Level_number=j;
head->last_Level->follow=0;
head->last_Level->nodes=MApFO((long int)head->last_Level->number_of_nodes);
for(i=0; ilast_Level->number_of_nodes; i++)
{
*(head->last_Level->nodes+i)=MAFO((long int)1);
(*(head->last_Level->nodes+i))->number_of_characteristics=head->last_Level->ahead->number_of_nodes;
(*(head->last_Level->nodes+i))->m.notes=0.0;
(*(head->last_Level->nodes+i))->actual=0;
(*(head->last_Level->nodes+i))->first=0;
for(k=0; k<(*(head->last_Level->nodes+i))->number_of_characteristics; k++)
{
(*(head->last_Level->nodes+i))->last=MACl((long int)1);
if((*(head->last_Level->nodes+i))->first==0) (*(head->last_Level->nodes+i))->first=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->last->name=0;
(*(head->last_Level->nodes+i))->last->membership=1.0;
(*(head->last_Level->nodes+i))->last->set=*(head->last_Level->ahead->nodes+k);
(*(head->last_Level->nodes+i))->last->follow=0;
(*(head->last_Level->nodes+i))->last->ahead=(*(head->last_Level->nodes+i))->actual;
if((*(head->last_Level->nodes+i))->actual!=0) (*(head->last_Level->nodes+i))->actual->follow=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->actual=(*(head->last_Level->nodes+i))->last;
};
/* adding BIAS input */
(*(head->last_Level->nodes+i))->actual=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->last=MACl((long int)1);
(*(head->last_Level->nodes+i))->last->name=MAC((long int)sizeof("BIAS"));
sprintf((*(head->last_Level->nodes+i))->last->name, "BIAS");
(*(head->last_Level->nodes+i))->last->membership=1.0;
(*(head->last_Level->nodes+i))->last->set=BIAS_fuzzy_object;
(*(head->last_Level->nodes+i))->last->follow=0;
(*(head->last_Level->nodes+i))->last->ahead=(*(head->last_Level->nodes+i))->actual;
if((*(head->last_Level->nodes+i))->actual!=0) (*(head->last_Level->nodes+i))->actual->follow=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->number_of_characteristics++;
};
};
head->output=MAFO((long int)1);
head->output->m.name=MAC((long int)7);
*(head->output->m.name+0)='O';
*(head->output->m.name+1)='U';
*(head->output->m.name+2)='T';
*(head->output->m.name+3)='P';
*(head->output->m.name+4)='U';
*(head->output->m.name+5)='T';
*(head->output->m.name+6)=' ';
head->output->number_of_characteristics=head->last_Level->number_of_nodes;
head->output->first=0;
head->output->actual=0;
for(i=0; ioutput->number_of_characteristics; i++)
{
head->output->last=MACl((long int)1);
if(head->output->first==0) head->output->first=head->output->last;
head->output->last->name=0;
head->output->last->membership=0.0;
head->output->last->set=*(head->last_Level->nodes+i);
head->output->last->ahead=head->output->actual;
head->output->last->follow=0;
if(head->output->actual!=0) head->output->actual->follow=head->output->last;
head->output->actual=head->output->last;
};
filling_weights_with_randum_numbers(head);
return(head);
} /* ; */
neuron *create_FCNN_with_only_1_output(fuzzy_set *input, int number_of_Levels)
/* create the neuron of FCNN with only 1 characteristic in the output fuzzy object type and with given number of layers. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to all nodes). The each successive Level nodes are receving inputs each from all nodes of the preceded Level. Output fuzzy object consists just one characteristics as there are nodes in the last Level, while number of nodes per Level linearly decreases from the first Level (the same number of nodes as input fuzzy set characteristics) toward the last one (only one characteristic). */
{
neuron *head;
int i,j,k;
/*float *weights;
enum Bool check;*/
head=MAN((long int)1);
head->name=0;
head->number_of_Levels=number_of_Levels;
/* creation of the first Level */
head->first_Level=MALe((long int)1);
head->actual_Level=head->first_Level;
head->last_Level=head->first_Level;
head->first_Level->follow=0;
head->first_Level->ahead=0;
/* checking if BIAS_fuzzy_object is already allocated, and allocating it if not */
if(BIAS_fuzzy_object==NULL)
{
BIAS_fuzzy_object=MAFO((long int)1);
BIAS_fuzzy_object->m.notes=(float)BIAS;
BIAS_fuzzy_object->first=0;
BIAS_fuzzy_object->actual=0;
BIAS_fuzzy_object->last=0;
BIAS_fuzzy_object->number_of_characteristics=0;
};
for(i=0, head->first_Level->number_of_nodes=0; inumber_of_objects; i++)
head->first_Level->number_of_nodes+=(*(input->objects+i))->number_of_characteristics;
head->first_Level->Level_number=1;
head->first_Level->nodes=MApFO((long int)head->first_Level->number_of_nodes);
for(i=0; ifirst_Level->number_of_nodes; i++)
{
*(head->first_Level->nodes+i)=MAFO((long int)1);
(*(head->first_Level->nodes+i))->number_of_characteristics=head->first_Level->number_of_nodes;
(*(head->first_Level->nodes+i))->m.notes=0.0;
(*(head->first_Level->nodes+i))->actual=0;
(*(head->first_Level->nodes+i))->first=0;
for(j=0, k=0; jnumber_of_objects; j++)
for((*(input->objects+j))->actual=(*(input->objects+j))->first; (*(input->objects+j))->actual!=0;(*(input->objects+j))->actual=(*(input->objects+j))->actual->follow, k++)
{
(*(head->first_Level->nodes+i))->last=MACl((long int)1);
if((*(head->first_Level->nodes+i))->first==0) (*(head->first_Level->nodes+i))->first=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->last->name=0;
(*(head->first_Level->nodes+i))->last->membership=1.0;
(*(head->first_Level->nodes+i))->last->set=(fuzzy_object*)(&((*(input->objects+j))->actual->membership));
(*(head->first_Level->nodes+i))->last->follow=0;
(*(head->first_Level->nodes+i))->last->ahead=(*(head->first_Level->nodes+i))->actual;
if((*(head->first_Level->nodes+i))->actual!=0) (*(head->first_Level->nodes+i))->actual->follow=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->actual=(*(head->first_Level->nodes+i))->last;
};
/* adding BIAS input */
(*(head->first_Level->nodes+i))->actual=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->last=MACl((long int)1);
(*(head->first_Level->nodes+i))->last->name=MAC((long int)sizeof("BIAS"));
sprintf((*(head->first_Level->nodes+i))->last->name, "BIAS");
(*(head->first_Level->nodes+i))->last->membership=1.0;
(*(head->first_Level->nodes+i))->last->set=(fuzzy_object*)(&(BIAS_fuzzy_object->m.notes));
(*(head->first_Level->nodes+i))->last->follow=0;
(*(head->first_Level->nodes+i))->last->ahead=(*(head->first_Level->nodes+i))->actual;
if((*(head->first_Level->nodes+i))->actual!=0) (*(head->first_Level->nodes+i))->actual->follow=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->number_of_characteristics++;
};
/* creation of remained Levels */
for(j=2; jnumber_of_Levels+1; j++)
{
head->last_Level=MALe((long int)1);
head->actual_Level->follow=head->last_Level;
head->last_Level->ahead=head->actual_Level;
head->actual_Level=head->last_Level;
head->last_Level->number_of_nodes=(int)ceil((double)((head->first_Level->number_of_nodes-1.0)*((head->number_of_Levels-j)/(head->number_of_Levels-1.0))+1.0)); /* number of nodes in actual Level = the lowest integer not less than { (number of nodes in the first Level - number of nodes in the last Level(=1))*[(number of Levels - actual Level number)/(number of Levels -1)] + number of nodes in the last Level(=1) } */
head->last_Level->Level_number=j;
head->last_Level->follow=0;
head->last_Level->nodes=MApFO((long int)head->last_Level->number_of_nodes);
for(i=0; ilast_Level->number_of_nodes; i++)
{
*(head->last_Level->nodes+i)=MAFO((long int)1);
(*(head->last_Level->nodes+i))->number_of_characteristics=head->last_Level->ahead->number_of_nodes;
(*(head->last_Level->nodes+i))->m.notes=0.0;
(*(head->last_Level->nodes+i))->actual=0;
(*(head->last_Level->nodes+i))->first=0;
for(k=0; k<(*(head->last_Level->nodes+i))->number_of_characteristics; k++)
{
(*(head->last_Level->nodes+i))->last=MACl((long int)1);
if((*(head->last_Level->nodes+i))->first==0) (*(head->last_Level->nodes+i))->first=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->last->name=0;
(*(head->last_Level->nodes+i))->last->membership=1.0;
(*(head->last_Level->nodes+i))->last->set=*(head->last_Level->ahead->nodes+k);
(*(head->last_Level->nodes+i))->last->follow=0;
(*(head->last_Level->nodes+i))->last->ahead=(*(head->last_Level->nodes+i))->actual;
if((*(head->last_Level->nodes+i))->actual!=0) (*(head->last_Level->nodes+i))->actual->follow=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->actual=(*(head->last_Level->nodes+i))->last;
};
/* adding BIAS input */
(*(head->last_Level->nodes+i))->actual=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->last=MACl((long int)1);
(*(head->last_Level->nodes+i))->last->name=MAC((long int)sizeof("BIAS"));
sprintf((*(head->last_Level->nodes+i))->last->name, "BIAS");
(*(head->last_Level->nodes+i))->last->membership=1.0;
(*(head->last_Level->nodes+i))->last->set=BIAS_fuzzy_object;
(*(head->last_Level->nodes+i))->last->follow=0;
(*(head->last_Level->nodes+i))->last->ahead=(*(head->last_Level->nodes+i))->actual;
if((*(head->last_Level->nodes+i))->actual!=0) (*(head->last_Level->nodes+i))->actual->follow=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->number_of_characteristics++;
};
};
head->output=MAFO((long int)1);
head->output->m.name=MAC((long int)7);
*(head->output->m.name+0)='O';
*(head->output->m.name+1)='U';
*(head->output->m.name+2)='T';
*(head->output->m.name+3)='P';
*(head->output->m.name+4)='U';
*(head->output->m.name+5)='T';
*(head->output->m.name+6)=' ';
head->output->number_of_characteristics=head->last_Level->number_of_nodes;
head->output->first=0;
head->output->actual=0;
for(i=0; ioutput->number_of_characteristics; i++)
{
head->output->last=MACl((long int)1);
if(head->output->first==0) head->output->first=head->output->last;
head->output->last->name=0;
head->output->last->membership=0.0;
head->output->last->set=*(head->last_Level->nodes+i);
head->output->last->ahead=head->output->actual;
head->output->last->follow=0;
if(head->output->actual!=0) head->output->actual->follow=head->output->last;
head->output->actual=head->output->last;
};
filling_weights_with_randum_numbers(head);
return(head);
} /* ; */
neuron *create_recurrent_FCNN(fuzzy_set *input, int number_of_Levels, int number_of_recurrent_connections, int *source, int *destination)
/* create the recurrent neuron of FCNN type with given number of layers (int number_of_Levels), number of feedback connections (int number_of_recurrent_connections) and given vector of feedback origin (int *source) and vector of feedback destination (int *destination). Vectors source and destination have number_of_recurrent_connections elements each and their elements presents pairs (source,destination) each pair presents one recurrent (feedback) (and no necessary recurrent) connection. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to all nodes). The each successive Level nodes are receving inputs each from all nodes of the preceded Level plus, if the Level number is inside the vector destination, from its pair (in the vector source) nodes' output. Output fuzzy object consists as many characteristics as there are nodes in the last Level (= number of nodes in each Level = number of input fuzzy set objects' characteristics). */
/* each characteristic presenting feedback weight (means all characteristics created in this function) has name "r " */
{
neuron *head;
Level *s, *d;
int i,j,k;
head=create_FCNN(input, number_of_Levels);
head->name=MAC((long int)5);
head->name="r ";
for(i=0; ihead->number_of_Levels)||(*(destination+i)>head->number_of_Levels)) exit_handling(90,1); /* means Level number in either vector source or destination (or in both of them) is higher than number of Levels in the neuron */
for(i=0; ifirst_Level; j<*(source+i); j++)
s=s->follow;
for(j=1, d=head->first_Level; j<*(destination+i); j++)
d=d->follow;
for(j=0; jnumber_of_nodes; j++)
for(k=0; knumber_of_nodes; k++)
{
(*(d->nodes+j))->number_of_characteristics++;
(*(d->nodes+j))->actual=(*(d->nodes+j))->last;
(*(d->nodes+j))->last=MACl((long int)1);
(*(d->nodes+j))->last->name=MAC((long int)5);
(*(d->nodes+j))->last->name="r ";
(*(d->nodes+j))->last->membership=(float)(rand()/32767.);
(*(d->nodes+j))->last->set=*(s->nodes+k);
(*(d->nodes+j))->last->follow=0;
(*(d->nodes+j))->last->ahead=(*(d->nodes+j))->actual;
(*(d->nodes+j))->actual->follow=(*(d->nodes+j))->last;
};
};
return(head);
} /* ; */
neuron *create_recurrent_FCNN_with_only_1_output(fuzzy_set *input, int number_of_Levels, int number_of_recurrent_connections, int *source, int *destination)
/* create the recurrent neuron of FCNN with only 1 output type with given number of layers (int number_of_Levels), number of feedback connections (int number_of_recurrent_connections) and given vector of feedback origin (int *source) and vector of feedback destination (int *destination). Vectors source and destination have number_of_recurrent_connections elements each and their elements presents pairs (source,destination) each pair presents one recurrent (feedback) (and no necessary recurrent) connection. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to all nodes). The each successive Level nodes are receving inputs each from all nodes of the preceded Level plus, if the Level number is inside the vector destination, from its pair (in the vector source) nodes' output. Output fuzzy object consists as many characteristics as there are nodes in the last Level (just one). Number of nodes linearly decrease from the first layer (as many nodes as input characteristics) toward the last layer (only one node). */
/* each characteristic presenting feedback weight (means all characteristics created in this function) has name "r " */
{
neuron *head;
Level *s, *d;
int i,j,k;
head=create_FCNN_with_only_1_output(input, number_of_Levels);
head->name=MAC((long int)5);
head->name="r ";
for(i=0; ihead->number_of_Levels)||(*(destination+i)>head->number_of_Levels)) exit_handling(91,1); /* means Level number in either vector source or destination (or in both of them) is higher than number of Levels in the neuron */
for(i=0; ifirst_Level; j<*(source+i); j++)
s=s->follow;
for(j=1, d=head->first_Level; j<*(destination+i); j++)
d=d->follow;
for(j=0; jnumber_of_nodes; j++)
for(k=0; knumber_of_nodes; k++)
{
(*(d->nodes+j))->number_of_characteristics++;
(*(d->nodes+j))->actual=(*(d->nodes+j))->last;
(*(d->nodes+j))->last=MACl((long int)1);
(*(d->nodes+j))->last->name=MAC((long int)5);
(*(d->nodes+j))->last->name="r ";
(*(d->nodes+j))->last->membership=(float)(rand()/32767.);
(*(d->nodes+j))->last->set=*(s->nodes+k);
(*(d->nodes+j))->last->follow=0;
(*(d->nodes+j))->last->ahead=(*(d->nodes+j))->actual;
(*(d->nodes+j))->actual->follow=(*(d->nodes+j))->last;
};
};
return(head);
} /* ; */
neuron *create_recurrent_FCNN_FB1(fuzzy_set *input, int number_of_Levels, int number_of_recurrent_connections, int *source, int *destination)
/* create the recurrent neuron of FCNN_FB1 type with given number of layers (int number_of_Levels), number of feedback connections (int number_of_recurrent_connections) and given vector of feedback origin (int *source) and vector of feedback destination (int *destination). Vectors source and destination have number_of_recurrent_connections elements each and their elements presents pairs (source,destination) each pair presents one recurrent (feedback) (and no necessary recurrent) connection. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to all nodes). The each successive Level nodes are receving inputs each from all nodes of the preceded Level plus, if the Level number is inside the vector destination, from its pair (in the vector source) nodes' output. Output fuzzy object consists as many characteristics as there are nodes in the last Level (= number of nodes in each Level = number of input fuzzy set objects' characteristics). */
/* each characteristic presenting feedback weight (means all characteristics created in this function) has name "r " */
/* FB1 meansfeedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) */
{
neuron *head;
Level *s, *d;
int i,j;
head=create_FCNN(input, number_of_Levels);
head->name=MAC((long int)5);
head->name="r ";
for(i=0; ihead->number_of_Levels)||(*(destination+i)>head->number_of_Levels)) exit_handling(92,1); /* means Level number in either vector source or destination (or in both of them) is higher than number of Levels in the neuron */
for(i=0; ifirst_Level; j<*(source+i); j++)
s=s->follow;
for(j=1, d=head->first_Level; j<*(destination+i); j++)
d=d->follow;
for(j=0; j<((d->number_of_nodesnumber_of_nodes)? d->number_of_nodes: s->number_of_nodes); j++)
{
(*(d->nodes+j))->number_of_characteristics++;
(*(d->nodes+j))->actual=(*(d->nodes+j))->last;
(*(d->nodes+j))->last=MACl((long int)1);
(*(d->nodes+j))->last->name=MAC((long int)5);
(*(d->nodes+j))->last->name="r ";
(*(d->nodes+j))->last->membership=(float)(rand()/32767.);
(*(d->nodes+j))->last->set=*(s->nodes+j);
(*(d->nodes+j))->last->follow=0;
(*(d->nodes+j))->last->ahead=(*(d->nodes+j))->actual;
(*(d->nodes+j))->actual->follow=(*(d->nodes+j))->last;
};
};
return(head);
} /* ; */
neuron *create_recurrent_FCNN_FB1_with_only_1_output(fuzzy_set *input, int number_of_Levels, int number_of_recurrent_connections, int *source, int *destination)
/* create the recurrent neuron of FCNN_FB1 with only 1 output type with given number of layers (int number_of_Levels), number of feedback connections (int number_of_recurrent_connections) and given vector of feedback origin (int *source) and vector of feedback destination (int *destination). Vectors source and destination have number_of_recurrent_connections elements each and their elements presents pairs (source,destination) each pair presents one recurrent (feedback) (and no necessary recurrent) connection. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to all nodes). The each successive Level nodes are receving inputs each from all nodes of the preceded Level plus, if the Level number is inside the vector destination, from its pair (in the vector source) nodes' output. Output fuzzy object consists as many characteristics as there are nodes in the last Level (just one). Number of nodes linearly decrease from the first layer (as many nodes as input characteristics) toward the last layer (only one node). */
/* each characteristic presenting feedback weight (means all characteristics created in this function) has name "r " */
/* FB1 means feedback one to one (means each node from feedback source is producing feedback onto its pair node of feedback destination and its the node on the same place inside destination layer as source is inside source layer, while in a case whan source layer has more nodes than destination layer only nodes that have their pair inside destination layer run feedback and similarly if destination layer has more nodes than source layer only nodes having their pair inside the source layer receive feedback, number of feedback connections is limited with lower of number of nodes in source layer and number of nodes in destination layer) */
{
neuron *head;
Level *s, *d;
int i,j;
head=create_FCNN_with_only_1_output(input, number_of_Levels);
head->name=MAC((long int)5);
head->name="r ";
for(i=0; ihead->number_of_Levels)||(*(destination+i)>head->number_of_Levels)) exit_handling(93,1); /* means Level number in either vector source or destination (or in both of them) is higher than number of Levels in the neuron */
for(i=0; ifirst_Level; j<*(source+i); j++)
s=s->follow;
for(j=1, d=head->first_Level; j<*(destination+i); j++)
d=d->follow;
for(j=0; j<((d->number_of_nodesnumber_of_nodes)? d->number_of_nodes: s->number_of_nodes); j++)
{
(*(d->nodes+j))->number_of_characteristics++;
(*(d->nodes+j))->actual=(*(d->nodes+j))->last;
(*(d->nodes+j))->last=MACl((long int)1);
(*(d->nodes+j))->last->name=MAC((long int)5);
(*(d->nodes+j))->last->name="r ";
(*(d->nodes+j))->last->membership=(float)(rand()/32767.);
(*(d->nodes+j))->last->set=*(s->nodes+j);
(*(d->nodes+j))->last->follow=0;
(*(d->nodes+j))->last->ahead=(*(d->nodes+j))->actual;
(*(d->nodes+j))->actual->follow=(*(d->nodes+j))->last;
};
};
return(head);
} /* ; */
neuron *create_FCNN_1L_1out_fixed_weights(fuzzy_set *input)
/* create the neuron of FCNN with only 1 layer and only 1 characteristic in the output fuzzy object type. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics (all characteristics to one node). Output fuzzy object consists just one characteristics as there are nodes in the first and only Level. */
/* all weights are preset on the value stored in extern float fixed_weight */
{
neuron *n;
n=create_FCNN_1L_1out(input);
fixing_weights(n);
return(n);
} /* ; */
void fixing_weights(neuron *n)
/* fixing weights (setting all weights on the same value) on the value stored in extern float fixed_weight */
{
extern float fixed_weight;
int i;
for(n->actual_Level=n->first_Level; n->actual_Level!=0; n->actual_Level=n->actual_Level->follow)
for(i=0; iactual_Level->number_of_nodes; i++)
for((*(n->actual_Level->nodes+i))->actual=(*(n->actual_Level->nodes+i))->first; (*(n->actual_Level->nodes+i))->actual!=0; (*(n->actual_Level->nodes+i))->actual=(*(n->actual_Level->nodes+i))->actual->follow)
(*(n->actual_Level->nodes+i))->actual->membership=fixed_weight;
} /* ; */
float sum_of_all_weighted_inputs(fuzzy_object *node, int Level_number)
/* sum of all inputs multiplied each with its weight (membership of pointer onto the input), included for the bias, is returned. */
/* the bias is defined in "neuro.h" as BIAS=1, but could be redefined if you defined it (#define BIAS __) before including "neuro.h" */
/* value "int Level_number" has meaning to distinguist the first Level from other Levels */
{
float sum=0.0;
if(Level_number==1)
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
sum+=(*((float*)(node->actual->set)))*node->actual->membership;
else
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
sum+=node->actual->set->m.notes*node->actual->membership;
return(sum);
} /* ; */
float product_of_all_weighted_inputs(fuzzy_object *node, int Level_number)
/* product of all inputs multiplied each with its weight (membership of pointer onto the input) is returned. */
/* value "int Level_number" has meaning to distinguist the first Level from other Levels */
{
float product=1.0;
if(Level_number==1)
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
product*=(*((float*)(node->actual->set)))*node->actual->membership;
else
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
product*=node->actual->set->m.notes*node->actual->membership;
return(product);
} /* ; */
float highest_weighted_input(fuzzy_object *node, int Level_number)
/* the highest value (input*weight) all inputs multiplied each with its weight (membership of pointer onto the input) is returned. */
/* value "int Level_number" has meaning to distinguist the first Level from other Levels */
{
register float Max=-1.0, mem;
if(Level_number==1)
{
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
{
mem=(*((float*)(node->actual->set)))*node->actual->membership;
if(mem>Max) Max=mem;
};
}
else
{
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
{
mem=node->actual->set->m.notes*node->actual->membership;
if(mem>Max) Max=mem;
};
};
return(Max);
} /* ; */
void firing_standard_neuron(neuron *head, nucleotide_base *code)
/* calculate processing of input through neuron onto output. Node output function is pointed inside neuron's nucleide base. Common/extern float treasureholdadd variable is used for defining treasurehold and can be set using function "void treasurehold_set(float new_treasurehold)" prior to the function executing. */
{
int i;
/* calculation of nodes output propagation */
for(head->actual_Level=head->first_Level; head->actual_Level!=0; head->actual_Level=head->actual_Level->follow)
for(i=0; iactual_Level->number_of_nodes; i++)
(*(head->actual_Level->nodes+i))->m.notes=code->node_output(code->node_linear_output(*(head->actual_Level->nodes+i), head->actual_Level->Level_number));
/* copying the last Level output onto output fuzzy object */
for(head->output->actual=head->output->first; head->output->actual!=0; head->output->actual=head->output->actual->follow)
head->output->actual->membership=head->output->actual->set->m.notes;
} /* ; */
void firing_recurrent_neuron(neuron *head, nucleotide_base *code)
/* calculate processing of input through neuron onto output. Node output function is pointed inside neuron's nucleide base. Common/extern float treasureholdadd variable is used for defining treasurehold and can be set using function "void treasurehold_set(float new_treasurehold)" prior to the function executing. */
/* firing_recurent_neuron() fires firing_standard_neuron() until neuron output is stabilised (means diverge not more than limit [each last Level nodes' output is not changed more than limit since previous fireing]) or Maximal_number_of_iterations is reached (that is the case neuron output diverge) */
{
int i,j=0, Maximal_number_of_iterations=100;
float limit=(float)0.1, *old_output;
enum Bool flag;
old_output=MAF((long int)head->output->number_of_characteristics);
firing_standard_neuron(head, code);
for(i=0, head->output->actual=head->output->first; ioutput->number_of_characteristics; i++, head->output->actual=head->output->actual->follow)
*(old_output+i)=head->output->actual->membership;
do
{
j++;
flag=T;
firing_standard_neuron(head, code);
for(i=0, head->output->actual=head->output->first; ioutput->number_of_characteristics; i++, head->output->actual=head->output->actual->follow)
{
if(((*(old_output+i))-head->output->actual->membership>limit)||(head->output->actual->membership-(*(old_output+i))>limit)) flag=F;
*(old_output+i)=head->output->actual->membership;
};
}
while((flag==F)&&(jactual_Level=head->first_Level; head->actual_Level!=0; head->actual_Level=head->actual_Level->follow)
{
buffer=MAF((long int)head->actual_Level->number_of_nodes);
for(i=0; iactual_Level->number_of_nodes; i++)
*(buffer+i)=code->node_output(code->node_linear_output(*(head->actual_Level->nodes+i), head->actual_Level->Level_number));
for(i=0; iactual_Level->number_of_nodes; i++)
(*(head->actual_Level->nodes+i))->m.notes=*(buffer+i);
testfree((char*)buffer);
};
/* copying the last Level output onto output fuzzy object */
for(head->output->actual=head->output->first; head->output->actual!=0; head->output->actual=head->output->actual->follow)
head->output->actual->membership=head->output->actual->set->m.notes;
} /* ; */
void firing_recurrent_neuron_with_feedback(neuron *head, nucleotide_base *code)
/* calculate processing of input through neuron onto output. Node output function is pointed inside neuron's nucleide base. Common/extern float treasureholdadd variable is used for defining treasurehold and can be set using function "void treasurehold_set(float new_treasurehold)" prior to the function executing. */
/* firing_recurent_neuron_with_feedback() fires firing_feedback_neuron() until neuron output is stabilised (means diverge not more than limit [each last Level nodes' output is not changed more than limit since previous fireing]) or Maximal_number_of_iterations is reached (that is the case neuron output diverge) */
/* this function is specially developed for neurons with feedback (recurrent connection) within the same layer but CAN HANDLE also STANDARD NEURON */
/* while processing a layer new output is stored into a buffer and at the end copied from the buffer onto nodes' output */
{
int i,j=0, Maximal_number_of_iterations=100;
float limit=(float)0.1, *old_output;
enum Bool flag;
old_output=MAF((long int)head->output->number_of_characteristics);
firing_feedback_neuron(head, code);
for(i=0, head->output->actual=head->output->first; ioutput->number_of_characteristics; i++, head->output->actual=head->output->actual->follow)
*(old_output+i)=head->output->actual->membership;
do
{
j++;
flag=T;
firing_feedback_neuron(head, code);
for(i=0, head->output->actual=head->output->first; ioutput->number_of_characteristics; i++, head->output->actual=head->output->actual->follow)
{
if(((*(old_output+i))-head->output->actual->membership>limit)||(head->output->actual->membership-(*(old_output+i))>limit)) flag=F;
*(old_output+i)=head->output->actual->membership;
};
}
while((flag==F)&&(jactual=node->first; node->actual!=0;)
{
for(product=1.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) product*=(*((float*)(node->actual->set)))*node->actual->membership;
else if(i==4) product*=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
else mem=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
};
if(i<5) exit_handling(7,i);
sum+=product;
}
else if(Level_number>1)
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) product*=node->actual->set->m.notes*node->actual->membership;
else if(i==4) product*=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
else mem=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
};
if(i<5) exit_handling(7,i);
sum+=product;
}
else if(Level_number==-1)
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
product*=(*((float*)(node->actual->set)))*node->actual->membership;
if(i<3) exit_handling(13,i);
sum+=product;
}
else
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
product*=node->actual->set->m.notes*node->actual->membership;
if(i<3) exit_handling(13,i);
sum+=product;
};
return(sum);
} /* ; */
float sum_of_roots_of_2multiplications_with_maximum_of_3(fuzzy_object *node, int Level_number)
/* input is considered as consequtive (non-overlapping) groups of five weighted inputs the first two of them are multiplicated with the maximal value (the highest one) of the following three inputs and than third roots of all (means of each of them) products are sumed (i.e. output= third_root(input1*input2*Max(input3,input4,input5)) + third_root(input6*input7*Max(input8,input9,input10)) + third_root(input11*input12*Max(input13,input14,input15)) + third_root(input16*input17*Max(input18,input19,input20)) + ....). In the case number of inputs is not divisible with five exit (exit_handling(8,remainder of (number of inputs/5))) is caused. */
/* in the case Level_number<0, there is only 3 inputs while output is sum of third roots of multiplications of them as written above. In the case number of inputs is not divisible with 3 exit (exit_handling(14,remainder of (number of inputs/3))) is caused. */
{
float sum=0.0, product, mem;
int i;
if(Level_number==1)
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) product*=(*((float*)(node->actual->set)))*node->actual->membership;
else if(i==4) product*=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
else mem=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
};
if(i<5) exit_handling(8,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
}
else if(Level_number>1)
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) product*=node->actual->set->m.notes*node->actual->membership;
else if(i==4) product*=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
else mem=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
};
if(i<5) exit_handling(8,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
}
else if(Level_number==-1)
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
product*=(*((float*)(node->actual->set)))*node->actual->membership;
if(i<3) exit_handling(14,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
}
else
for(node->actual=node->first; node->actual!=0;)
{
for(product=1.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
product*=node->actual->set->m.notes*node->actual->membership;
if(i<3) exit_handling(14,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
};
return(sum);
} /* ; */
float arithmetic_mean_of_roots_of_2multiplications_with_maximum_of_3(fuzzy_object *node, int Level_number)
/* input is considered as consequtive (non-overlapping) groups of five weighted inputs the first two of them are multiplicated with the maximal value (the highest one) of the following three inputs and than arithmetic mean of third roots of all products calculated (i.e. output= arithmetic mean(third_root(input1*input2*Max(input3,input4,input5)), third_root(input6*input7*Max(input8,input9,input10)), third_root(input11*input12*Max(input13,input14,input15)), third_root(input16*input17*Max(input18,input19,input20)), ....)). In the case number of inputs is not divisible with five exit (exit_handling(9,remainder of (number of inputs/5))) is caused. */
/* in the case Level_number<0, there is only 3 inputs while output is arithmetic mean of third roots of multiplications of them as written above. In the case number of inputs is not divisible with 3 exit (exit_handling(15,remainder of (number of inputs/3))) is caused. */
{
float sum=0.0, product, mem;
int i, i3=0;
if(Level_number==1)
for(node->actual=node->first; node->actual!=0; i3++)
{
for(product=1.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) product*=(*((float*)(node->actual->set)))*node->actual->membership;
else if(i==4) product*=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
else mem=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
};
if(i<5) exit_handling(9,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
}
else if(Level_number>1)
for(node->actual=node->first; node->actual!=0; i3++)
{
for(product=1.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) product*=node->actual->set->m.notes*node->actual->membership;
else if(i==4) product*=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
else mem=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
};
if(i<5) exit_handling(9,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
}
else if(Level_number==-1)
for(node->actual=node->first; node->actual!=0; i3++)
{
for(product=1.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
product*=(*((float*)(node->actual->set)))*node->actual->membership;
if(i<3) exit_handling(15,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
}
else
for(node->actual=node->first; node->actual!=0; i3++)
{
for(product=1.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
product*=node->actual->set->m.notes*node->actual->membership;
if(i<3) exit_handling(15,i);
sum+=(float)pow((double)product, (double) 1.0/3.0);
};
return(sum/i3);
} /* ; */
float highest_arithmetic_mean_of_2_with_maximum_of_3(fuzzy_object *node, int Level_number)
/* input is considered as consequtive (non-overlapping) groups of five weighted inputs arithmetic mean is calculated of the first two and the maximal value (the highest one) of the following three inputs and the highest one proceeded on output (i.e. output= Max(arithmetic mean(input1*input2*Max(input3,input4,input5)), arithmetic mean(input6*input7*Max(input8,input9,input10)), arithmetic mean(input11*input12*Max(input13,input14,input15)), arithmetic mean(input16*input17*Max(input18,input19,input20)), ....)). In the case number of inputs is not divisible with five exit (exit_handling(10,remainder of (number of inputs/5))) is caused. */
/* in the case Level_number<0, there is only 3 inputs while output is the highest arithmetic mean of multiplications of them as written above. In the case number of inputs is not divisible with 3 exit (exit_handling(16,remainder of (number of inputs/3))) is caused. */
{
float sum, mem, Max=-10.0;
int i;
if(Level_number==1)
for(node->actual=node->first; node->actual!=0;)
{
for(sum=0.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) sum+=(*((float*)(node->actual->set)))*node->actual->membership;
else if(i==4) sum+=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
else mem=((*((float*)(node->actual->set)))*node->actual->membership>mem)?(*((float*)(node->actual->set)))*node->actual->membership:mem;
};
if(i<5) exit_handling(10,i);
if((sum/3)>Max) Max=sum/3;
}
else if(Level_number>1)
for(node->actual=node->first; node->actual!=0;)
{
for(sum=0.0, i=0, mem=-10.0; (i<5)&&(node->actual!=0); i++, node->actual=node->actual->follow)
{
if(i<2) sum+=node->actual->set->m.notes*node->actual->membership;
else if(i==4) sum+=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
else mem=(node->actual->set->m.notes*node->actual->membership>mem)?node->actual->set->m.notes*node->actual->membership:mem;
};
if(i<5) exit_handling(10,i);
if((sum/3)>Max) Max=sum/3;
}
else if(Level_number==-1)
for(node->actual=node->first; node->actual!=0;)
{
for(sum=0.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
sum+=(*((float*)(node->actual->set)))*node->actual->membership;
if(i<3) exit_handling(16,i);
if((sum/3)>Max) Max=sum/3;
}
else
for(node->actual=node->first; node->actual!=0;)
{
for(sum=0.0, i=0; (i<3)&&(node->actual!=0); i++, node->actual=node->actual->follow)
sum+=node->actual->set->m.notes*node->actual->membership;
if(i<3) exit_handling(16,i);
if((sum/3)>Max) Max=sum/3;
};
return(Max);
} /* ; */
float product_of_first_n_with_complements_of_rest(fuzzy_object *node, int n)
/* output is product of the first n inputs and the rest of inputs are complemented. It means: "output=input1*input2*....*inputn*(1-input(n+1))*(1-input(n+2))*(1-input(n+3))*...*(1-inputlast)" */
/* also each input is multiplied with its (characteristic) weight prior to multiplying with other inputs or their complements */
{
float product;
int i;
for(i=0, product=1.0, node->actual=node->first; node->actual!=0; i++, node->actual=node->actual->follow)
if(iactual->set)))*node->actual->membership; /* NOTE: input is multiplied with the weight! */
else
product*=((float)1.0-(*((float*)(node->actual->set)))*node->actual->membership);
return(product);
} /* ; */
void filling_weights_with_randum_numbers(neuron *head)
/* fills weights inside the neuron with random numbers from [0,1] real interval. Randomisation is reached using random number generator randomised by general time (datum+actual time) and processor time. */
/* extern int sequence_randomiser is used to add additional dimension of randomness as when is a sequence randomise because of high processor frequence time(0) and clock() are not necessary changed inbetween elements */
{
int i;
extern int sequence_randomiser;
sequence_randomiser=(int)fmod((double)(++sequence_randomiser),(double)32768.0);
srand((int)fmod((double)(time(0)+clock()),(double)32768.0));
for(head->actual_Level=head->first_Level; head->actual_Level!=0; head->actual_Level=head->actual_Level->follow)
for(i=0; iactual_Level->number_of_nodes; i++)
for((*(head->actual_Level->nodes+i))->actual=(*(head->actual_Level->nodes+i))->first; (*(head->actual_Level->nodes+i))->actual!=0; (*(head->actual_Level->nodes+i))->actual=(*(head->actual_Level->nodes+i))->actual->follow)
(*(head->actual_Level->nodes+i))->actual->membership=(float)(rand()/32767.);
} /* ; */
/* functions that deal on neuron population level */
fuzzy_set **preparing_neuron_population_neuron_inputs_through_window(neuron_population *np, int window_radius, int horisontal_resolution, int vertical_resolution)
/* Returns pointer on array of pointers on fuzzy sets (the same number of fuzzy sets as fuzzy objects in input fuzzy set). Prepares neuron population's neurones' input fuzzy sets from neuron population input fuzzy set presenting "picture" with dimension horisontal_resolution * vertical_resolution in a following way: each fuzzy object in neural population's input fuzzy set becomes the first fuzzy object in one and only one neuron's (inside the population) input fuzzy set, other fuzzy objects in input fuzzy set of a neuron (inside population) are fuzzy objects placed on the neuron population input "picture" inside window radius from the first object in the neuron's input (or better said placed inside square each side equal two times window radius with center in the first object in neuron's input). It is similar as shifting square window (each side=2*window_radius) on the picture and inputing the central pixel as the first followed by other pixel inside window. If neuron population has different number of neurones than its input fuzzy set unsucessful program termination is caused (exit(1)) ! */
/* When returned array is used memory consisting data not necessary for future work should be liberate (using command testfree())! This usually means following: "for(i=0; inumber_of_neurones; testfree((char*)(*(head+i))->name), testfree((char*)(*(head+i))->objects), testfree((char*)*(head+i++))); testfree((char*)head);" after creating neuron population's neurones. */
{
int h,v,i,c,a,b;
fuzzy_set **head;
if(np->number_of_neurones!=np->input->number_of_objects) exit_handling(3,1);
head=MApFS((long int)np->number_of_neurones);
for(i=0; inumber_of_neurones; i++)
{
*(head+i)=MAFS((long int)1);
(*(head+i))->name=MAC((long int)2);
*((*(head+i))->name+0)='I';
*((*(head+i))->name+1)=' ';
a=(int)fmod((double)i,(double)horisontal_resolution);
b=(int)floor(((double)i)/((double)horisontal_resolution));
/* (*(head+i))->number_of_objects=((((int)(a)+window_radius0)?a-window_radius:0)+1)*((((int)(b)+window_radius0)?b-window_radius:0)+1);
*/ (*(head+i))->number_of_objects=((((int)(a)+window_radius0)?a-window_radius:0)+1)*((((int)(b)+window_radius0)?b-window_radius:0)+1);
(*(head+i))->objects=MApFO((long int)(*(head+i))->number_of_objects);
*((*(head+i))->objects+0)=*(np->input->objects+i);
for(c=1, h=((int)(a)-window_radius<0)?0:a-window_radius; h<((a+window_radius+1objects+c)=*(np->input->objects+v*horisontal_resolution+h);
};
};
return(head);
} /* ; */
fuzzy_set *many2one(int number_of_sets, fuzzy_set **sets)
/* Create new fuzzy set pointing on all objects member of fuzzy sets pointed by array sets. Variable number_of_sets meand how many fuzzy sets are pointed by array sets. Array sets consists pointers on fuzzy sets. */
/* The created fuzzy set has the name THE NUMBER OF FUZZY SETS IT CONSISTS ! */
/* After use when new fuzzy set (as set of pointers on fuzzy objects) is no more required memory should be liberated usually in following way: "testfree((char*)fuzzy_set_pointer->name);testfree((char*)fuzzy_set_pointer->objects);testfree((char*)fuzzy_set_pointer);", where "fuzzy_set_pointer" is name given to the pointer on the fuzzy set (means earlier in program such command as fuzzy_set_pointer=many2one(....). */
{
fuzzy_set *head;
float ns;
int i, j, k, l;
head=MAFS((long int)1);
i=0;
ns=(float)number_of_sets;
do
{
ns/=10.;
i++;
}while(ns>=1.0);
head->name=MAC((long int)i+1);
l=number_of_sets;
k=number_of_sets/10;
for(j=i-1; j>-1; k/=10, l/=10, j--)
*(head->name+j)=(char)(l-10*k+48);
*(head->name+i)=' ';
for(head->number_of_objects=0, i=0; inumber_of_objects+=(*(sets+i))->number_of_objects;
head->objects=MApFO((long int)head->number_of_objects);
for(j=0, i=0; inumber_of_objects; j++, k++)
*(head->objects+j)=*((*(sets+i))->objects+k);
return(head);
} /* ; */
neuron_population *create_neuron_population(nucleotide_base *code, int number_of_neurones_in_population, fuzzy_set *input, int window_radius, int horisontal_input_resolution, int vertical_input_resolution, fuzzy_set** (*prepare_input)(neuron_population*, int, int, int))
/* Creates neuron population from information stored in its nucleotide base. "number_of_neurones_in_population" presents number of neurones to be created to form the population. "input" is fuzzy set used as input in the population. In the case input is union of several fuzzy sets the required one should be defined by creating new structure fuzzy_set consisting pointers on all fuzzy_objects presenting input into the population (it can be done using function many2one()). "window_radius", "horisontal_input_resolution" and "vertical_input_resolution" are to be used in function pointed by "prepare_input" and in the case prepare_input=nill their values are not of interest and are not used in the function. "prepare_input()" is pointer on function that rearrange neurones' inputs from the population's input by forming array of fuzzy sets each fuzzy set for one and only one neuron in the population. In the case all neurones receive input from all fuzzy objects in the population's input fuzzy set input preparing function is NOT REQUIRED so should be "prepare_input=nill" ! */
/* Pointer toward root population IS SET UP AS NILL and SHOULD BE WRITTEN LATER as well as number_of_leaf_populations that IS also SET UP AS NILL. Array of pointers toward leaf populations IS NOT CREATED (MEMORY IS NOT RESERVED) while pointer on the array (**leaf) IS NILL and SHOULD BE CREATED AND FILLED LATER ! */
/* In the case input is wanted to be considered as 2 dimensional (for organisation of the population's neurones inputs) horisontal_input_resolution presents horisontal and vertical_input_resolution vertical dimension of input "picture" (pixel=fuzzy object), while window_radius presents radius (half of window side's lenght) of window for each of the population's neuron input. In that case must be satisfied "horisontal_input_resolution*vertical_input_resolution=input->number_of_objects" and "window_radius>0". */
{
int i;
neuron_population *head;
fuzzy_set **input_p;
head=MANP((long int)1);
head->code=code;
head->number_of_neurones=number_of_neurones_in_population;
head->neurones=MApN((long int)head->number_of_neurones);
head->number_of_leaf_populations=0;
head->root=0;
head->leaf=0;
head->input=input;
head->output=MAFS((long int)1);
head->output->name=MAC((long int)2);
*(head->output->name+0)='O';
*(head->output->name+0)=' ';
head->output->number_of_objects=head->number_of_neurones;
head->output->objects=MApFO((long int)head->output->number_of_objects);
if(prepare_input==0)
for(i=0; inumber_of_neurones; i++)
{
*(head->neurones+i)=head->code->create_neuron(input);
*(head->output->objects+i)=(*(head->neurones+i))->output;
}
else
{
input_p=(prepare_input)(head, window_radius, horisontal_input_resolution, vertical_input_resolution);
for(i=0; inumber_of_neurones;i++)
{
*(head->neurones+i)=head->code->create_neuron(*(input_p+i));
*(head->output->objects+i)=(*(head->neurones+i))->output;
testfree((char*)(*(input_p+i))->name);
testfree((char*)(*(input_p+i))->objects);
testfree((char*)*(input_p+i));
};
testfree((char*)input_p);
};
head->learning_algorithm=0; /* learning algorithm should be created later or this line should be changed to head->learning_algorithm=code->create_population_learning_algorithm(code,head); */
return(head);
} /*; */
void fire_neuron_population(neuron_population *np)
/* fire_neuron_population() fires neuron population by firing each neuron inside the population */
{
int i;
for(i=0; inumber_of_neurones; i++)
np->code->firing_neuron(*(np->neurones+i), np->code);
} /*; */
void fill_neuron_population_root_and_leaf(struct neuron_population *np, int number_of_leaf, int number_of_root, struct neuron_population **root, struct neuron_population **leaf)
/* creates and fills vectors root and leaf inside the neuron population consisting pointers onto neuron populations the population receives input from (root) and proceedings output to (leaf) */
{
int i;
np->number_of_root_populations=number_of_root;
np->number_of_leaf_populations=number_of_leaf;
if(np->number_of_root_populations>0)
np->root=MApNP((long int)np->number_of_root_populations);
if(np->number_of_leaf_populations>0)
np->leaf=MApNP((long int)np->number_of_leaf_populations);
for(i=0; inumber_of_root_populations; i++)
*(np->root+i)=*(root+i);
for(i=0; inumber_of_leaf_populations; i++)
*(np->leaf+i)=*(leaf+i);
} /* ; */
void delete_neuron_population(struct neuron_population *head)
/* deletes neuron population and releases its memory */
{
int i;
if(head->learning_algorithm!=0)
{
head->learning_algorithm->deleting(head->learning_algorithm);
head->learning_algorithm=0;
};
delete_fuzzy_set(head->output);
delete_fuzzy_set(head->input);
for(i=0; inumber_of_neurones; i++)
delete_neuron(*(head->neurones+i));
free((char*) head->neurones);
free((char*) head->root);
free((char*) head->leaf);
free((char*) head);
} /* ; */
/* functions that deal on neural subsystem level */
void creating_neural_subsystem_output(neural_subsystem *ns)
/* creates neural subsystem's output fuzzy set whose fuzzy objects are neural subsystem's root (last layer of neuron populations according the direction of information/input processing) neuron populations' output fuzzy sets in the same order as neuron populations inside the roots vector (of pointers) of the neural subsystem */
{
int i, j, k;
ns->output=MAFS((long int)1);
ns->output->name=MAC((long int)7);
*(ns->output->name+0)='O';
*(ns->output->name+1)='U';
*(ns->output->name+2)='T';
*(ns->output->name+3)='P';
*(ns->output->name+4)='U';
*(ns->output->name+5)='T';
*(ns->output->name+6)=' ';
ns->output->number_of_objects=ns->number_of_roots_populations;
ns->output->objects=MApFO((long int)ns->output->number_of_objects);
for(i=0, j=0; ioutput->number_of_objects; i++)
for(k=0; k<(*(ns->roots+i))->output->number_of_objects; k++)
*(ns->output->objects+j++)=*((*(ns->roots+i))->output->objects+k);
} /* ; */
void delete_neural_subsystem(struct neural_subsystem *head)
/* deletes neural subsystem and releases its memory */
{
int i;
for(i=0; inumber_of_populations; i++)
delete_neuron_population(*(head->firing_list+i));
free((char*) head->firing_list);
delete_fuzzy_set(head->output);
delete_fuzzy_set(head->input);
free((char*) head->root);
free((char*) head->leaf);
free((char*) head->roots);
free((char*) head->leaves);
if(head->output_is_shared!=0) free((char*) head->output_is_shared);
if(head->number_of_shared_inputs>0) free((char*) head->shared_inputs);
free((char*) head);
};
struct neural_subsystem *create_neural_subsystem_from_gene(gene *code, fuzzy_set *input)
/* creates neural system from information stored in its gene and input fuzzy set */
/* missing (important) part that should create neuron populations inside the subsystem and fill its pointers to leaves and root consisted neuron populations tree as well to other subsystems */
/* the problem is how to define/choose input fuzzy set per particular neuron population - maybe they should create input fuzzy set each for itself from their pointers on leaves neuron populations */
{
struct neural_subsystem *ns;
ns=MANSS((long int)1);
ns->code=code;
ns->number_of_populations=code->number_of_nucleotide_bases;
ns->number_of_roots_populations=0; /* should be done later manualy or a function for doing this made */
ns->number_of_leaves_populations=0; /* should be done later manualy or a function for doing this made */
ns->roots=0; /* should be done later manualy or a function for doing this made */
ns->leaves=0; /* should be done later manualy or a function for doing this made */
ns->number_of_root_subsystems=0; /* should be done later manualy or a function for doing this made */
ns->number_of_leaf_subsystems=0; /* should be done later manualy or a function for doing this made */
ns->root=0; /* should bu done later manualy or a function for doing this made */
ns->leaf=0; /* should bu done later manualy or a function for doing this made */
ns->input=input;
ns->shared_inputs=0;
ns->output_is_shared=0;
ns->number_of_shared_inputs=-1;
creating_neural_subsystem_output(ns);
return(ns);
} /* ; */
void filling_neural_subsystem_tree_of_neural_populations(struct neural_subsystem *ns, struct neuron_population ***populations_with_leaves, int *number_of_leaves)
/* fills both, the neural_subsystem's roots and leaves vectors and its populations' root and leaf vectors, from the vector populations_with_leaves that has as many elements as there are populations inside the subsystem, each of them pointing to vector of pointers first one onto the related population (according its identification_number) followed by its leaves, the number of leaves is stored on the same position (inside the vector) in the vector number_of_leaves. The populations in the vector populations_with_leaves are stored starting from the subsystem's root populations toward the leaves, in the same order as populations' related identification_numbers should be */
{
int i, j, k, number_of_roots;
struct neuron_population **roots, **leaves;
enum Bool r;
/* filling populations' vectors of pointers to their roots and leaves */
for(i=0; inumber_of_populations; i++)
{
roots=MApNP((long int)ns->number_of_populations);
for(j=0, number_of_roots=0; jnumber_of_populations; j++)
for(k=0; k<*(number_of_leaves+j); k++)
if((*(*(populations_with_leaves+j)+k+1))==*(*(populations_with_leaves+i)+0)) *(roots+number_of_roots++)=*(*(populations_with_leaves+j)+0);
leaves=(*(number_of_leaves+i)>0)?MApNP((long int)*(number_of_leaves+i)): 0;
for(j=0; j<*(number_of_leaves+i); j++)
*(leaves+j)=*(*(populations_with_leaves+i)+j+1);
fill_neuron_population_root_and_leaf(*(*(populations_with_leaves+i)+0), *(number_of_leaves+i), number_of_roots, roots, leaves);
free((char*)roots);
if(leaves!=0) free((char*)leaves);
};
/* filling the subsystem's vectors roots and leaves */
for(ns->number_of_roots_populations=0, ns->number_of_leaves_populations=0, roots=(ns->number_of_populations>0)?MApNP((long int)ns->number_of_populations):0, leaves=(ns->number_of_populations>0)?MApNP((long int)ns->number_of_populations):0, i=0; inumber_of_populations; i++)
{
/* searching for root populations */
for(j=0, r=T; (jnumber_of_populations)&&(r==T); j++)
for(k=0; (k<*(number_of_leaves+j))&&(r==T); k++)
if(*(*(populations_with_leaves+j)+k+1)==*(*(populations_with_leaves+i)+0)) r=F;
if(r==T) *(roots+ns->number_of_roots_populations++)=*(*(populations_with_leaves+i)+0);
/* searching for leaves populations */
for(j=0, r=T; (j<*(number_of_leaves+i))&&(r==T); j++)
for(k=0; (knumber_of_populations)&&(r==T); k++)
if(*(*(populations_with_leaves+k)+0)==*(*(populations_with_leaves+i)+j+1)) r=F;
if(r==T) *(leaves+ns->number_of_leaves_populations++)=*(*(populations_with_leaves+i)+0);
};
/* filling the subsystem's vector roots */
if(ns->number_of_roots_populations>0)
{
ns->roots=MApNP((long int)ns->number_of_roots_populations);
for(i=0; inumber_of_roots_populations; i++)
*(ns->roots+i)=*(roots+i);
}
else
{
ns->root=0; /* means there is a recurrent connection from root populations so they must be selected on another way */
exit_handling(1007,1);
};
if(roots!=0) free((char*)roots);
/* filling the subsystem's vector leaves */
if(ns->number_of_leaves_populations>0)
{
ns->leaves=MApNP((long int)ns->number_of_leaves_populations);
for(i=0; inumber_of_leaves_populations; i++)
*(ns->leaves+i)=*(leaves+i);
}
else
{
ns->leaves=0; /* means there is a recurrent connection to leaves populations so they must be selected on another way */
exit_handling(1007,2);
};
if(leaves!=0) free((char*)leaves);
} /* ; */
void fill_neural_subsystem_root_and_leaf(struct neural_subsystem *ns, int number_of_leaf, int number_of_root, struct neural_subsystem **root, struct neural_subsystem **leaf)
/* creates and fills vectors root and leaf inside the neural subsystem consisting pointers onto neural subsystems the subsystem receives input from (root) and proceedings output to (leaf) */
{
int i;
ns->number_of_root_subsystems=number_of_root;
ns->number_of_leaf_subsystems=number_of_leaf;
if(ns->number_of_root_subsystems>0)
ns->root=MApNSS((long int)ns->number_of_root_subsystems);
if(ns->number_of_leaf_subsystems>0)
ns->leaf=MApNSS((long int)ns->number_of_leaf_subsystems);
for(i=0; inumber_of_root_subsystems; i++)
*(ns->root+i)=*(root+i);
for(i=0; inumber_of_leaf_subsystems; i++)
*(ns->leaf+i)=*(leaf+i);
} /* ; */
neural_subsystem *create_neural_subsystem_from_gene_and_subsystem_tree(struct gene *code, struct subsystem_tree *tree, neuron_population ***virtual_populations, enum Bool **inputs)
/* creates neural subsystem from information provided in related gene and subsystem tree, while virtual_populations and inputs enable creation of neuron populations that receive input or proceed output outside from/of their subsystem as well as implementing recurrent connections. virtual_populations must be an allocated space of memory dimension = number_of_subsystems_in_the_system * number_of_populations_in_the_subsystem(subsystem_identification(order)_number=row_number(0-number_of_subsystems-1)+1), first column is pointers to subsystems, while other in a row point to populations belonging to the subsystem in the first column and are organised in order according populations' numbers inside the subsystem_tree, and if population/subsystem is not created yet pointer must be 0 otherwise point to related population/subsystem. inputs is Boolean matrix each element shows if its neuron population, pointed on the equivalent position of virtual_populations without the first row, has undefined input fuzzy_set, must be preset on F while T means the related population has undefined (at the moment) input fuzzy set. */
{
neural_subsystem *ns;
nucleotide_base *nb;
fuzzy_set **fs;
neuron_population **np, ***populations_with_leaves;
int i, j, k, *number_of_leaves;
if(code->number_of_nucleotide_bases!=tree->number_of_populations) exit_handling(1008,1); /* different number of populations to be created in the gene and the subsystem tree */
/* creating subsystem and filling it */
ns=MANSS((long int)1);
ns->number_of_populations=code->number_of_nucleotide_bases;
ns->code=code;
ns->system=0;
ns->number_of_leaf_subsystems=0;
ns->number_of_root_subsystems=0;
ns->leaf=0;
ns->root=0;
ns->shared_inputs=0;
ns->output_is_shared=0;
ns->number_of_shared_inputs=-1;
/* subscribing the subsystem to virtual_populations */
*(*(virtual_populations+tree->identification_number-1)+0)=(neuron_population*)ns;
/* creating the subsystem's populations and subscribing them to virtual_populations together with defining of their input fuzzy set and noting into inputs */
for(i=ns->number_of_populations; i>0; i--)
{
*(*(inputs+tree->identification_number-1)+i-1)=F;
np=MApNP((long int)tree->number_of_leaf_pairs+tree->number_of_leaf_in_other_subsystems);
k=0;
/* first finding i-th populations inputs outside of the subsystem */
if(tree->number_of_leaf_in_other_subsystems>0)
{
for(j=0; (*(tree->leaf_in_other_subsystems[0]+j)!=i)&&(jnumber_of_leaf_in_other_subsystems); )
j++;
if(jnumber_of_leaf_in_other_subsystems)
for( ; (*(tree->leaf_in_other_subsystems[0]+j)==i)&&(*(*(inputs+tree->identification_number-1)+i-1)==F); j++)
{
*(np+k++)=*(*(virtual_populations+(*(tree->leaf_in_other_subsystems[1]+j))-1)+(*(tree->leaf_in_other_subsystems[2]+j)));
if(*(np+k-1)==0) *(*(inputs+tree->identification_number-1)+i-1)=T;
};
};
/* then finding i-th populations inputs inside the subsystem */
if(tree->number_of_leaf_pairs>0)
{
for(j=0; (*(tree->leaf_pairs[0]+j)!=i)&&(jnumber_of_leaf_pairs); )
j++;
if(jnumber_of_leaf_pairs)
for( ; (*(tree->leaf_pairs[0]+j)==i)&&(*(*(inputs+tree->identification_number-1)+i-1)==F); j++)
{
if(*(tree->leaf_pairs[1]+j)==0)
{
*(np+k++)=0; /* 0 means input is input fuzzy_set (whose identification_number is assumed as 0) */
}
else
{
*(np+k++)=*(*(virtual_populations+tree->identification_number-1)+(*(tree->leaf_pairs[1]+j)));
if(*(np+k-1)==0) *(*(inputs+tree->identification_number-1)+i-1)=T;
};
};
};
/* searching for the gene related/describing the population to be created */
for(nb=ns->code->gene_begin; (nb->identification_number!=i)&&(nb->identification_numbernumber_of_populations+1); )
nb=nb->follow;
if(nb->identification_number>ns->number_of_populations) exit_handling(1008,2); /* can't find the related gene */
/* creating the i-th population */
if(*(*(inputs+tree->identification_number-1)+i-1)==F)
{
fs=MApFS((long int)k);
for(j=0; jinput: (*(np+j))->output;
*(*(virtual_populations+tree->identification_number-1)+i)=nb->type->create_neuron_population_from_nucleotide_base(nb, many2one(k,fs));
free((char*)fs);
}
else
{
if(nb->type->create_neuron_population_from_nucleotide_base_without_input==0)
{
exit_handling(1008,3); /* there is no written function for creating neuron population without having input fuzzy set, while input fuzzy set is undefined at the moment */
}
else
{
*(*(virtual_populations+tree->identification_number-1)+i)=nb->type->create_neuron_population_from_nucleotide_base_without_input(nb);
};
};
(*(*(virtual_populations+tree->identification_number-1)+i))->subsystem=ns;
free((char*)np);
};
/* filling the subsystem's tree structure (populations' pointers root and leaf) and pointers roots and leaves */
populations_with_leaves=MAppNP((long int)ns->number_of_populations);
number_of_leaves=MAI((long int)ns->number_of_populations);
for(i=1; inumber_of_populations+1; i++)
{
*(populations_with_leaves+i-1)=MApNP((long int)tree->number_of_leaf_pairs+tree->number_of_leaf_in_other_subsystems);
*(*(populations_with_leaves+i-1)+0)=*(*(virtual_populations+tree->identification_number-1)+i);
*(number_of_leaves+i-1)=0;
if(tree->number_of_leaf_in_other_subsystems>0)
{
for(j=0; (*(tree->leaf_in_other_subsystems[0]+j)!=i)&&(jnumber_of_leaf_in_other_subsystems); )
j++;
if(jnumber_of_leaf_in_other_subsystems)
for( ; *(tree->leaf_in_other_subsystems[0]+j)==i; j++)
{
*(*(populations_with_leaves+i-1)+(++*(number_of_leaves+i-1)))=*(*(virtual_populations+(*(tree->leaf_in_other_subsystems[1]+j))-1)+(*(tree->leaf_in_other_subsystems[2]+j)));
if(*(*(populations_with_leaves+i-1)+(*(number_of_leaves+i-1)))==0) *(*(populations_with_leaves+i-1)+(*(number_of_leaves+i-1)))=(neuron_population*)(-1);
};
};
if(tree->number_of_leaf_pairs>0)
{
for(j=0; (*(tree->leaf_pairs[0]+j)!=i)&&(jnumber_of_leaf_pairs); )
j++;
if(jnumber_of_leaf_pairs)
for( ; *(tree->leaf_pairs[0]+j)==i; j++)
if(*(tree->leaf_pairs[1]+j)!=0)
{
if(*(*(virtual_populations+tree->identification_number-1)+(*(tree->leaf_pairs[1]+j)))==0)
{
(int)(*(*(populations_with_leaves+i-1)+(++*(number_of_leaves+i-1))))=-1;
}
else
{
*(*(populations_with_leaves+i-1)+(++*(number_of_leaves+i-1)))=*(*(virtual_populations+tree->identification_number-1)+(*(tree->leaf_pairs[1]+j)));
};
};
};
};
filling_neural_subsystem_tree_of_neural_populations(ns,populations_with_leaves,number_of_leaves);
/* filling the subsystem's firing_list */
ns->firing_list=MApNP((long int)ns->number_of_populations);
/* since populations in the subsystem's subsystem tree must be numerised in order from roots to leaves it seems the most reasonable to use the inverse order for firing them. Therefore populations in firing_list are in inverse order then numerised inside the subsystem tree. The list can be manualy, or by an additional function, rearranged */
for(i=0; inumber_of_populations; i++)
*(ns->firing_list+i)=*(*(virtual_populations+tree->identification_number-1)+ns->number_of_populations-i);
/* releasing previously reserved memory */
for(i=1; inumber_of_populations+1; i++)
free((char*)(*(populations_with_leaves+i-1)));
free((char*)populations_with_leaves);
free((char*)number_of_leaves);
/* creating the subsystem's output and input fuzzy sets */
creating_neural_subsystem_output(ns);
if(tree->input==0)
{
fs=MApFS((long int)ns->number_of_leaves_populations);
for(i=0, j=0; inumber_of_leaves_populations; i++)
{
*(fs+i)=(*(ns->leaves+i))->input;
if((int)(*(fs+i))<=0) j=1;
};
if(j==0)
{
ns->input=many2one(ns->number_of_leaves_populations,fs);
}
else
{
ns->input=(fuzzy_set*)(-1);
};
free((char*)fs);
}
else
{
ns->input=tree->input;
};
/* returning pointer on the subsystem */
return(ns);
} /* ; */
void fire_neural_subsystem(struct neural_subsystem *ns)
/* fires neural subsystem by firing its populations in the same order as written (pointers) in its vector firing_list */
{
int i;
for(i=0; inumber_of_populations; i++)
fire_neuron_population(*(ns->firing_list+i));
} /* ; */
/* teaching subsystem */
void create_learning_algorithms_inside_subsystem(struct neural_subsystem *ns, float learning_constant)
/* creates learning algorithm for all populations (and therefore all neurones) inside the subsystem with chosen learning constant */
/* also (creates and) fills vectors shared_inputs and output_is_shared when (the subsystem's) number_of_shared_inputs is less than zero */
{
int i, j, k, l, n_i;
float **temp, **temp1;
enum Bool exist;
characteristic *ac;
/* creation of learning algorithms of the subsystem's populations */
for(i=ns->number_of_populations-1; i>-1; i--)
(*(ns->firing_list+i))->learning_algorithm=(*(ns->firing_list+i))->code->create_population_learning_algorithm((*(ns->firing_list+i))->code, *(ns->firing_list+i), learning_constant);
/* creating and filling vectors shared_inputs and output_is_shared when (the subsystem's) number_of_shared_inputs is less than zero by searching for shared inputs among the populations inside the subsystem and tracking info about them */
if(ns->number_of_shared_inputs<0) /* it means it is not filled during a creation of previous (if any) the subsystem ('s populations) learning algorithms */
{
for(n_i=0, i=0; inumber_of_populations; i++)
for(j=0; j<(*(ns->firing_list+i))->input->number_of_objects; j++)
for((*((*(ns->firing_list+i))->input->objects+j))->actual=(*((*(ns->firing_list+i))->input->objects+j))->first; (*((*(ns->firing_list+i))->input->objects+j))->actual!=0; (*((*(ns->firing_list+i))->input->objects+j))->actual=(*((*(ns->firing_list+i))->input->objects+j))->actual->follow)
for(k=i+1; knumber_of_populations; k++)
for(l=0; l<(*(ns->firing_list+k))->input->number_of_objects; l++)
for(ac=(*((*(ns->firing_list+k))->input->objects+l))->first; ac!=0; ac=ac->follow)
if(ac==(*((*(ns->firing_list+i))->input->objects+j))->actual)
n_i++;
temp=MApF((long int)n_i); /* temp points to all shared inputs */
for(n_i=0, i=0; inumber_of_populations; i++)
for(j=0; j<(*(ns->firing_list+i))->input->number_of_objects; j++)
for((*((*(ns->firing_list+i))->input->objects+j))->actual=(*((*(ns->firing_list+i))->input->objects+j))->first; (*((*(ns->firing_list+i))->input->objects+j))->actual!=0; (*((*(ns->firing_list+i))->input->objects+j))->actual=(*((*(ns->firing_list+i))->input->objects+j))->actual->follow)
for(k=i+1; knumber_of_populations; k++)
for(l=0; l<(*(ns->firing_list+k))->input->number_of_objects; l++)
for(ac=(*((*(ns->firing_list+k))->input->objects+l))->first; ac!=0; ac=ac->follow)
if(ac==(*((*(ns->firing_list+i))->input->objects+j))->actual)
*(temp+n_i++)=&(ac->membership); /* pointing on the shared input */
/* reducing temp with duplicated inputs */
if(n_i>0)
{
temp1=MApF((long int)n_i);
}
else
{
temp1=0;
};
for(ns->number_of_shared_inputs=0, i=0; inumber_of_shared_inputs++)=*(temp+i);
};
free((char*) temp); /* releasing temp's memory */
/* moving pointers from temp1 into ns->shared_inputs to save allocated memory */
if(ns->number_of_shared_inputs>0)
{
ns->shared_inputs=MApF((long int)ns->number_of_shared_inputs);
}
else
{
ns->shared_inputs=0;
};
for(i=0; inumber_of_shared_inputs; i++)
*(ns->shared_inputs+i)=*(temp1+i);
if(temp1!=0) free((char*) temp1); /* releasing temp's memory */
/* creating and filling of the vector output_is_shared */
ns->output_is_shared=MAEB((long int)ns->number_of_populations); /* ns->output_is_shared is set T if its population's output is shared between/among any populations inside the subsystem */
for(i=0; inumber_of_populations; i++)
*(ns->output_is_shared+i)=F;
for(i=0; inumber_of_populations; i++)
for(k=0; k<(*(ns->firing_list+i))->output->number_of_objects; k++)
for((*((*(ns->firing_list+i))->output->objects+k))->actual=(*((*(ns->firing_list+i))->output->objects+k))->first; (*((*(ns->firing_list+i))->output->objects+k))->actual!=0; (*((*(ns->firing_list+i))->output->objects+k))->actual=(*((*(ns->firing_list+i))->output->objects+k))->actual->follow)
for(j=0; jnumber_of_shared_inputs; j++)
if(&((*((*(ns->firing_list+i))->output->objects+k))->actual->membership)==*(ns->shared_inputs+j)) *(ns->output_is_shared+i)=T;
};
} /* ; */
void fire_learning_algorithms_inside_subsystem(struct neural_subsystem *ns)
/* fires learning algorithm for all populations (and therefore all neurones) inside the subsystem */
/* it (usually) doesn't include weights update */
/* also cares for the case some populations share the same input to enable each population to have original value while its learning is trigged and to have updated valu on the output if its output is shared */
/* at the end all inputs are set to updated (by firing learning) values */
{
int i, j, k/*, l */;
float *mem1, *mem2;
if(ns->number_of_shared_inputs>0)
{
mem1=MAF((long int)ns->number_of_shared_inputs); /* mem1 is vector of original input values for all shared inputs */
mem2=MAF((long int)ns->number_of_shared_inputs); /* mem1 is vector of updated input values for all shared inputs */
}
else
{
mem1=0;
mem2=0;
};
for(i=0; inumber_of_shared_inputs; i++)
{
*(mem1+i)=**(ns->shared_inputs+i);
*(mem2+i)=*(mem1+i);
};
/* firing learning algorithms and refreshing shared inputs and updating their values when becomming outputs */
for(i=ns->number_of_populations-1; i>-1; i--)
{
if(*(ns->output_is_shared+i)==T)
for(j=0; jnumber_of_shared_inputs; j++)
for(k=0; k<(*(ns->firing_list+i))->output->number_of_objects; k++)
for((*((*(ns->firing_list+i))->output->objects+k))->actual=(*((*(ns->firing_list+i))->output->objects+k))->first; (*((*(ns->firing_list+i))->output->objects+k))->actual!=0; (*((*(ns->firing_list+i))->output->objects+k))->actual=(*((*(ns->firing_list+i))->output->objects+k))->actual->follow)
if(&((*((*(ns->firing_list+i))->output->objects+k))->actual->membership)==*(ns->shared_inputs+j)) (*((*(ns->firing_list+i))->output->objects+k))->actual->membership=*(mem2+j); /* updating output value according all updates of it as an input */
/* firing learning algorithm */
(*(ns->firing_list+i))->learning_algorithm->fire((*(ns->firing_list+i))->learning_algorithm);
/* for population whose learning algorithm is being fired shares its inputs they (it's made by reverting all shared inputs) must be reverted to original value from mem1 and updates stored inside mem2 */
for(k=0; knumber_of_shared_inputs; k++)
{
*(mem2+k)+=**(ns->shared_inputs+k)-(*(mem1+k)); /* updating input's updated value according the corrections through i-th population */
**(ns->shared_inputs+k)=(*(mem1+k)); /* storing original value into shared input */
};
if(*(ns->output_is_shared+i)==T)
for(j=0; jnumber_of_shared_inputs; j++)
for(k=0; k<(*(ns->firing_list+i))->output->number_of_objects; k++)
for((*((*(ns->firing_list+i))->output->objects+k))->actual=(*((*(ns->firing_list+i))->output->objects+k))->first; (*((*(ns->firing_list+i))->output->objects+k))->actual!=0; (*((*(ns->firing_list+i))->output->objects+k))->actual=(*((*(ns->firing_list+i))->output->objects+k))->actual->follow)
if(&((*((*(ns->firing_list+i))->output->objects+k))->actual->membership)==*(ns->shared_inputs+j))
if(**(ns->shared_inputs+j)==*(mem2+j)) **(ns->shared_inputs+j)=*(mem1+j); /* changing output value to the original one because of recurrent connections, except when it's already changed through changing shared inputs (because of recurrent connections) */
};
/* releasing reserved memory not required any more */
if(mem1!=0) free((char*) mem1);
/* replacing all shared input values with updated ones */
for(i=0; inumber_of_shared_inputs; i++)
**(ns->shared_inputs+i)=*(mem2+i);
if(mem2!=0) free((char*) mem2);
} /* ; */
void learning_algorithms_weights_correction_inside_subsystem(struct neural_subsystem *ns)
/* updates weights for all populations (and therefore all neurones) inside the subsystem */
{
int i;
for(i=ns->number_of_populations-1; i>-1; i--)
if((*(ns->firing_list+i))->learning_algorithm->weights_correction!=0) (*(ns->firing_list+i))->learning_algorithm->weights_correction((*(ns->firing_list+i))->learning_algorithm);
} /* ; */
void learning_algorithms_reset_weights_correction_inside_subsystem(struct neural_subsystem *ns)
/* reset weights correction for all populations (and therefore all neurones) inside the subsystem */
{
int i;
for(i=ns->number_of_populations-1; i>-1; i--)
if((*(ns->firing_list+i))->learning_algorithm->reset_weights_correction!=0) (*(ns->firing_list+i))->learning_algorithm->reset_weights_correction((*(ns->firing_list+i))->learning_algorithm);
} /* ; */
void delete_learning_algorithms_inside_subsystem(struct neural_subsystem *ns)
/* deletes learning algorithm for all populations (and therefore all neurones) inside the subsystem */
{
int i;
for(i=ns->number_of_populations-1; i>-1; i--)
if((*(ns->firing_list+i))->learning_algorithm!=0)
{
(*(ns->firing_list+i))->learning_algorithm->deleting((*(ns->firing_list+i))->learning_algorithm);
(*(ns->firing_list+i))->learning_algorithm=0;
};
} /* ; */
void change_subsystem_learning_rate(struct neural_subsystem *ns, float new_learning_rate)
/* changes learning rate into already existing neural subsystem's populations' learning algorithm (includes changing of learning rate into consisted neuron learning algorithms) */
{
int i;
/* changing learning rate in consisted neuron populations */
for(i=0; inumber_of_populations; i++)
change_learning_algorithm_learning_rate((*(ns->firing_list+i))->learning_algorithm, new_learning_rate);
}/* ; */
/* functions that deal with neural_system */
neural_system *create_neural_system(struct chromosome *code, struct subsystem_tree **trees)
/* creates neural system together with filling tree structures inside the system (through calling required functions) and input fuzzy sets */
/* struct subsystem_tree **trees must consists subsystem trees of all subsystems inside the system in order from roots toward leaves. Opposite order is stored into the system's firing_list used for firing the subsystem. firing_list can be later manualy (or by an additional function) rearranged */
{
struct neural_system *s;
struct neuron_population ***virtual_populations;
struct fuzzy_set **in;
enum Bool **inputs;
int i, j, k, l, m, *roots, *leaves;
/* creating neural system and filling its structure */
s=MANS((long int)1);
s->code=code;
s->number_of_subsystems=code->number_of_genes;
s->number_of_shared_inputs=-1;
s->shared_inputs=0;
s->output_is_shared=0;
/* creating virtual_populations and inputs */
virtual_populations=MAppNP((long int)s->number_of_subsystems);
inputs=MApEB((long int)s->number_of_subsystems);
for(i=0; inumber_of_subsystems; i++)
{
*(virtual_populations+i)=MApNP((long int)(*(code->genes+i))->number_of_nucleotide_bases+1);
*(inputs+i)=MAEB((long int)(*(code->genes+i))->number_of_nucleotide_bases);
for(j=0; j<(*(code->genes+i))->number_of_nucleotide_bases; j++)
{
(*(*(virtual_populations+i)+j))=0;
*(*(inputs+i)+j)=F;
};
*(*(virtual_populations+i)+(*(code->genes+i))->number_of_nucleotide_bases)=0;
};
/* creating the system's neural subsystems */
for(i=s->number_of_subsystems-1; i>-1; i--)
{
*(*(virtual_populations+i)+0)=(struct neuron_population*)create_neural_subsystem_from_gene_and_subsystem_tree(*(code->genes+i), *(trees+i), virtual_populations, inputs);
((neural_subsystem*)(*(*(virtual_populations+i)+0)))->system=s;
};
/* filling still unfilled pointers (value<0) of neural populations inside the system */
for(i=s->number_of_subsystems-1; i>-1; i--)
for(j=1; j<(*(code->genes+i))->number_of_nucleotide_bases+1; j++)
for(k=0; k<(*(*(virtual_populations+i)+j))->number_of_leaf_populations; k++)
{
if((int)(*((*(*(virtual_populations+i)+j))->leaf+k))<0)
{
m=0;
for(l=0;(*((*(trees+i))->leaf_in_other_subsystems[0]+l)!=j)&&(l<(*(trees+i))->number_of_leaf_in_other_subsystems); )
l++;
if(j<(*(trees+i))->number_of_leaf_in_other_subsystems)
for( ; (*((*(trees+i))->leaf_in_other_subsystems[0]+l)==j)&&(m!=k); )
{
m++;
l++;
};
if(m==k)
{
*((*(*(virtual_populations+i)+j))->leaf+k)=*(*(virtual_populations+(*((*(trees+1))->leaf_in_other_subsystems[1]+l))-1)+(*((*(trees+i))->leaf_in_other_subsystems[2]+l)));
}
else
{
for(l=0; (*((*(trees+i))->leaf_pairs[0]+l)!=j)&&(l<(*(trees+i))->number_of_leaf_pairs); )
l++;
if(l>=(*(trees+i))->number_of_leaf_pairs) exit_handling(1009,1); /* required neuron population cannot be found inside its subsystem's subsystem tree */
for( ; (*((*(trees+i))->leaf_pairs[0]+l)==j)&&(m!=k); )
{
m++;
l++;
};
if(m!=k) exit_handling(1009,2); /* required leaf neuron population (to be pointed) can't be found inside virtual_populations */
*((*(*(virtual_populations+i)+j))->leaf+k)=*(*(virtual_populations+(*(trees+i))->identification_number-1)+(*((*(trees+i))->leaf_pairs[1]+l)));
};
};
if(*(*(inputs+i)+j-1)==T) exit_handling(1009,3); /* There is still undefined neuron population input fuzzy set and a function for treating it is not developed yet.A function for inserting fuzzy set should be inserted instead of this exit handling(1009,3). */
};
/* creating and filling firing_list with pointers on subsystems in inverse order than in vector trees */
s->firing_list=MApNSS((long int)s->number_of_subsystems);
for(i=s->number_of_subsystems; i>0; i--)
*(s->firing_list+s->number_of_subsystems-i)=(neural_subsystem*)(*(*(virtual_populations+i-1)+0));
/* creating and filling vectors roots and leaves */
s->number_of_roots_subsystems=0;
s->number_of_leaves_subsystems=0;
roots=MAI((long int)s->number_of_subsystems);
leaves=MAI((long int)s->number_of_subsystems);
for(i=0; inumber_of_subsystems; i++)
{
*(roots+i)=0;
*(leaves+i)=0;
};
/* searching for leaves subsystems */
for(i=0; inumber_of_subsystems; i++)
if((*(trees+i))->number_of_leaf_in_other_subsystems==0) *(leaves+s->number_of_leaves_subsystems++)=(*(trees+i))->identification_number;
/* searching for roots subsystems */
for(i=0; inumber_of_subsystems; i++)
{
for(j=0, m=0; (jnumber_of_subsystems)&&(m==0); j++)
for(k=0; (k<(*(trees+j))->number_of_leaf_in_other_subsystems)&&(m==0); k++)
if(*((*(trees+j))->leaf_in_other_subsystems[1]+k)==(*(trees+i))->identification_number) m=1;
if(m==0) *(roots+s->number_of_roots_subsystems++)=(*(trees+i))->identification_number;
};
/* saving roots subsystems */
if(s->number_of_roots_subsystems==0)
{
s->roots=0;
exit_handling(1009,4); /* this system has recurrent connections to its roots so roots have to be selected manualy, or by an additional function */
/* if the problem of selecting root subsystems is solved then disable exit_handling(1009,4) */
}
else
{
s->roots=MApNSS((long int)s->number_of_roots_subsystems);
for(i=0; inumber_of_roots_subsystems; i++)
*(s->roots+i)=(neural_subsystem*)(*(*(virtual_populations+(*(trees+(*(roots+i))-1))->identification_number-1)+0));
};
/* releasing roots memory */
free((char*)roots);
/* saving leaves subsystems */
if(s->number_of_leaves_subsystems==0)
{
s->leaves=0;
exit_handling(1009,5); /* this system has recurrent connections from its leaves so leaves have to be selected manualy, or by an additional function */
/* if the problem of selecting leaves subsystems is solved then disable exit_handling(1009,5) */
}
else
{
s->leaves=MApNSS((long int)s->number_of_leaves_subsystems);
for(i=0; inumber_of_leaves_subsystems; i++)
*(s->leaves+i)=(neural_subsystem*)(*(*(virtual_populations+(*(trees+(*(leaves+i))-1))->identification_number-1)+0));
};
/* releasing leaves memory */
free((char*)leaves);
/* releasing virtual_populations and inputs. If they are required for further/higher level processing the following code should be disabled and (pointers to) structures transfered into required functions */
for(i=0; inumber_of_subsystems; i++)
{
free((char*)(*(virtual_populations+i)));
free((char*)(*(inputs+i)));
};
free((char*)virtual_populations);
free((char*)inputs);
/* creating output fuzzy set */
in=MApFS((long int)s->number_of_roots_subsystems);
for(i=0; inumber_of_roots_subsystems; i++)
*(in+i)=(*(s->roots+i))->output;
s->output=many2one(s->number_of_roots_subsystems,in);
free((char*)in);
/* creating input fuzzy set */
in=MApFS((long int)s->number_of_leaves_subsystems);
for(i=0; inumber_of_leaves_subsystems; i++)
*(in+i)=(*(s->leaves+i))->input;
s->input=many2one(s->number_of_leaves_subsystems,in);
free((char*)in);
return(s);
} /* ; */
void delete_neural_system(struct neural_system *head)
/* deletes neural system and releases its memory */
{
int i;
for(i=0; inumber_of_subsystems; i++)
delete_neural_subsystem(*(head->firing_list+i));
free((char*) head->firing_list);
delete_fuzzy_set(head->output);
delete_fuzzy_set(head->input);
free((char*) head->roots);
free((char*) head->leaves);
if(head->number_of_shared_inputs>0) free((char*) head->shared_inputs);
if(head->number_of_shared_inputs>0) free((char*) head->output_is_shared);
free((char*) head);
};
void fire_neural_system(struct neural_system *s)
/* fires neural system by firing its subsystems in the same order as written (pointers) in its vector firing_list */
{
int i;
for(i=0; inumber_of_subsystems; i++)
fire_neural_subsystem(*(s->firing_list+i));
} /* ; */
float **finding_phantom_objects_inside_system(struct neural_system *s)
/* phantom objects are fuzzy objects inserted to present zero input when input window (local input field) gets out of the input fuzzy set (usually representing picture) */
/* returns vector of pointers on phantom objects' memberships, but the first value is not pointer but NUMBER OF PHANTOM OBJECTS' MEMBERSHIPS INSIDE THE POPULATION. So returned vector has number of pointers + 1 element */
{
float **p1, **p2;
int i, j, k, l, m, ip1, ip2;
enum Bool appeared;
/* reserving memory for storing pointers. It is supposed that there is no more phantom objects' memberships than all objects' memberships inside the system input fuzzy sets */
for(i=0, ip1=0; inumber_of_subsystems; i++)
for(j=0; j<(*(s->firing_list+i))->number_of_populations; j++)
for(k=0; k<(*((*(s->firing_list+i))->firing_list+j))->input->number_of_objects; k++)
ip1+=(*((*((*(s->firing_list+i))->firing_list+j))->input->objects+k))->number_of_characteristics;
p1=MApF((long int)ip1);
/* searching for phantom objects' memberships */
for(i=0, ip1=0; inumber_of_subsystems; i++)
for(j=0; j<(*(s->firing_list+i))->number_of_populations; j++)
for(k=0; k<(*((*(s->firing_list+i))->firing_list+j))->number_of_neurones; k++)
for(l=0; l<(*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->number_of_nodes; l++)
for((*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual=(*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->first; (*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual!=0; (*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual=(*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual->follow)
{
for(m=0, appeared=F; (m<(*((*(s->firing_list+i))->firing_list+j))->input->number_of_objects)&&(appeared==F); m++)
for((*((*((*(s->firing_list+i))->firing_list+j))->input->objects+m))->actual=(*((*((*(s->firing_list+i))->firing_list+j))->input->objects+m))->first; ((*((*((*(s->firing_list+i))->firing_list+j))->input->objects+m))->actual!=0)&&(appeared==F); (*((*((*(s->firing_list+i))->firing_list+j))->input->objects+m))->actual=(*((*((*(s->firing_list+i))->firing_list+j))->input->objects+m))->actual->follow)
if((*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual->set==(fuzzy_object*)(&((*((*((*(s->firing_list+i))->firing_list+j))->input->objects+m))->actual->membership)))
{
/* skipping BIAS_fuzzy_objects - name of weights pointing on it is "BIAS" */
if((*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual->name=NULL)
appeared=T;
else if((*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual->name!="BIAS")
appeared=T;
};
if(appeared==F) *(p1+ip1++)=(float*)(*((*((*((*(s->firing_list+i))->firing_list+j))->neurones+k))->first_Level->nodes+l))->actual->set;
};
if(ip1>0)
{
/* elimination of multiple appearance */
p2=MApF((long int)ip1);
for(i=0, ip2=0; inumber_of_subsystems-1; i>-1; i--)
create_learning_algorithms_inside_subsystem(*(s->firing_list+i), learning_constant);
/* creating and filling vectors shared_inputs and output_is_shared when (the system's) number_of_shared_inputs is less than zero by searching for shared inputs among the subsystems inside the system and tracking info about them */
if(s->number_of_shared_inputs<0) /* it means it is not filled during a creation of previous (if any) the system ('s subsystems' populations) learning algorithms */
{
for(n_i=0, i=0; inumber_of_subsystems; i++)
for(j=0; j<(*(s->firing_list+i))->input->number_of_objects; j++)
for((*((*(s->firing_list+i))->input->objects+j))->actual=(*((*(s->firing_list+i))->input->objects+j))->first; (*((*(s->firing_list+i))->input->objects+j))->actual!=0; (*((*(s->firing_list+i))->input->objects+j))->actual=(*((*(s->firing_list+i))->input->objects+j))->actual->follow)
for(k=i+1; knumber_of_subsystems; k++)
for(l=0; l<(*(s->firing_list+k))->input->number_of_objects; l++)
for(ac=(*((*(s->firing_list+k))->input->objects+l))->first; ac!=0; ac=ac->follow)
if(ac==(*((*(s->firing_list+i))->input->objects+j))->actual)
n_i++;
temp=MApF((long int)n_i); /* temp points to all shared inputs */
for(n_i=0, i=0; inumber_of_subsystems; i++)
for(j=0; j<(*(s->firing_list+i))->input->number_of_objects; j++)
for((*((*(s->firing_list+i))->input->objects+j))->actual=(*((*(s->firing_list+i))->input->objects+j))->first; (*((*(s->firing_list+i))->input->objects+j))->actual!=0; (*((*(s->firing_list+i))->input->objects+j))->actual=(*((*(s->firing_list+i))->input->objects+j))->actual->follow)
for(k=i+1; knumber_of_subsystems; k++)
for(l=0; l<(*(s->firing_list+k))->input->number_of_objects; l++)
for(ac=(*((*(s->firing_list+k))->input->objects+l))->first; ac!=0; ac=ac->follow)
if(ac==(*((*(s->firing_list+i))->input->objects+j))->actual)
*(temp+n_i++)=&(ac->membership); /* pointing on the shared input */
/* reducing temp with duplicated inputs */
if(n_i>0)
{
temp1=MApF((long int)n_i);
}
else
{
temp1=0;
};
for(s->number_of_shared_inputs=0, i=0; inumber_of_shared_inputs++)=*(temp+i);
};
free((char*) temp); /* releasing temp's memory */
/* moving pointers from temp1 into s->shared_inputs to save allocated memory */
if(s->number_of_shared_inputs>0)
{
s->shared_inputs=MApF((long int)s->number_of_shared_inputs);
}
else
{
s->shared_inputs=0;
};
for(i=0; inumber_of_shared_inputs; i++)
*(s->shared_inputs+i)=*(temp1+i);
if(temp1!=0) free((char*) temp1); /* releasing temp1's memory */
s->output_is_shared=MAEB((long int)s->number_of_subsystems); /* s->output_is_shared is set T if its subsystem's output is shared between/among any subsystems inside the system */
for(i=0; inumber_of_subsystems; i++)
*(s->output_is_shared+i)=F;
for(i=0; inumber_of_subsystems; i++)
for(k=0; k<(*(s->firing_list+i))->output->number_of_objects; k++)
for((*((*(s->firing_list+i))->output->objects+k))->actual=(*((*(s->firing_list+i))->output->objects+k))->first; (*((*(s->firing_list+i))->output->objects+k))->actual!=0; (*((*(s->firing_list+i))->output->objects+k))->actual=(*((*(s->firing_list+i))->output->objects+k))->actual->follow)
for(j=0; jnumber_of_shared_inputs; j++)
if(&((*((*(s->firing_list+i))->output->objects+k))->actual->membership)==*(s->shared_inputs+j)) *(s->output_is_shared+i)=T;
};
} /* ; */
void fire_learning_algorithms_inside_system(struct neural_system *s)
/* fires learning algorithm for all subsystems (and therefore all populations and all neurones) inside the system */
/* it (usually) doesn't include weights update */
/* also cares for the case some subsystems share the same input to enable each subsystem to have original value while its learning is trigged and to have updated valu on the output if its output is shared */
/* at the end all inputs are set to updated (by firing learning) values */
{
int i, j, k /*, l */;
float *mem1, *mem2;
if(s->number_of_shared_inputs>0)
{
mem1=MAF((long int)s->number_of_shared_inputs); /* mem1 is vector of original input values for all shared inputs */
mem2=MAF((long int)s->number_of_shared_inputs); /* mem1 is vector of updated input values for all shared inputs */
}
else
{
mem1=0;
mem2=0;
};
for(i=0; inumber_of_shared_inputs; i++)
{
*(mem1+i)=**(s->shared_inputs+i);
*(mem2+i)=*(mem1+i);
};
/* firing learning algorithms of the subsystems inside the system and refreshing shared inputs and updating their values when becomming outputs */
for(i=s->number_of_subsystems-1; i>-1; i--)
{
if(*(s->output_is_shared+i)==T)
for(j=0; jnumber_of_shared_inputs; j++)
for(k=0; k<(*(s->firing_list+i))->output->number_of_objects; k++)
for((*((*(s->firing_list+i))->output->objects+k))->actual=(*((*(s->firing_list+i))->output->objects+k))->first; (*((*(s->firing_list+i))->output->objects+k))->actual!=0; (*((*(s->firing_list+i))->output->objects+k))->actual=(*((*(s->firing_list+i))->output->objects+k))->actual->follow)
if(&((*((*(s->firing_list+i))->output->objects+k))->actual->membership)==*(s->shared_inputs+j)) (*((*(s->firing_list+i))->output->objects+k))->actual->membership=*(mem2+j); /* updating output value according all updates of it as an input */
/* firing learning algorithms inside the system's selected subsystem */
fire_learning_algorithms_inside_subsystem(*(s->firing_list+i));
/* if the subsystem whose learning algorithm is being fired shares its inputs they (it's made by reverting all shared inputs) must be reverted to original value from mem1 and updates stored inside mem2 */
for(k=0; knumber_of_shared_inputs; k++)
{
*(mem2+k)+=**(s->shared_inputs+k)-(*(mem1+k)); /* updating input's updated value according the corrections through i-th subsystem */
**(s->shared_inputs+k)=(*(mem1+k)); /* storing original value into shared input */
};
if(*(s->output_is_shared+i)==T)
for(j=0; jnumber_of_shared_inputs; j++)
for(k=0; k<(*(s->firing_list+i))->output->number_of_objects; k++)
for((*((*(s->firing_list+i))->output->objects+k))->actual=(*((*(s->firing_list+i))->output->objects+k))->first; (*((*(s->firing_list+i))->output->objects+k))->actual!=0; (*((*(s->firing_list+i))->output->objects+k))->actual=(*((*(s->firing_list+i))->output->objects+k))->actual->follow)
if(&((*((*(s->firing_list+i))->output->objects+k))->actual->membership)==*(s->shared_inputs+j))
if(**(s->shared_inputs+j)==*(mem2+j)) **(s->shared_inputs+j)=*(mem1+j); /* changing output value to the original one because of recurrent connections, except when it's already changed through changing shared inputs (because of recurrent connections) */
};
/* releasing reserved memory not required any more */
if(mem1!=0) free((char*) mem1);
/* replacing all shared input values with updated ones */
for(i=0; inumber_of_shared_inputs; i++)
**(s->shared_inputs+i)=*(mem2+i);
if(mem2!=0) free((char*) mem2);
} /* ; */
void learning_algorithms_weights_correction_inside_system(struct neural_system *s)
/* updates weights for all subsystems (and therefore all populations and all neurones) inside the system */
{
int i;
for(i=s->number_of_subsystems-1; i>-1; i--)
learning_algorithms_weights_correction_inside_subsystem(*(s->firing_list+i));
} /* ; */
void learning_algorithms_reset_weights_correction_inside_system(struct neural_system *s)
/* reset weights correction for all subsystems (and therefore all populations and all neurones) inside the system */
{
int i;
for(i=s->number_of_subsystems-1; i>-1; i--)
learning_algorithms_reset_weights_correction_inside_subsystem(*(s->firing_list+i));
} /* ; */
void delete_learning_algorithms_inside_system(struct neural_system *s)
/* deletes learning algorithm for all subsystems (and therefore all populations and all neurones) inside the system */
{
int i;
for(i=s->number_of_subsystems-1; i>-1; i--)
delete_learning_algorithms_inside_subsystem(*(s->firing_list+i));
} /* ; */
void change_system_learning_rate(struct neural_system *s, float new_learning_rate)
/* changes learning rate into already existing neural system's neural subsystems' populations' learning algorithm (includes changing of learning rate into consisted neuron learning algorithms) */
{
int i;
/* changing learning rate in consisted neuron populations */
for(i=0; inumber_of_subsystems; i++)
change_subsystem_learning_rate(*(s->firing_list+i), new_learning_rate);
}/* ; */
/* highest_difference_from_neighborns neuron functions */
neuron *create_highest_difference_from_neighborns(fuzzy_set *input)
/* create the neuron of highest_difference_from_neighborns type. Input fuzzy set (record) consists of (pointers on) fuzzy objects the first of them is the one whose the highest difference from neighborns is to be calculated while its neighborns follow. */
{
neuron *head;
int i;
float *weights;
enum Bool check;
head=MAN((long int)1);
head->name=0;
head->number_of_Levels=2;
head->first_Level=first_Level_highest_difference_from_neighborns(input);
weights=MAF((long int)head->first_Level->number_of_nodes*1);
for(i=0; ifirst_Level->number_of_nodes*1; i++)
*(weights+i)=1.0;
head->actual_Level=head->first_Level;
head->last_Level=fill_Level(2,head->first_Level->number_of_nodes,1,weights,head->actual_Level);
head->actual_Level->follow=head->last_Level;
check=setup_weights_pointers(head->last_Level,head->actual_Level);
if(check==F) exit_handling(2,1);
head->output=MAFO((long int)1);
head->output->m.name=MAC((long int)7);
*(head->output->m.name+0)='O';
*(head->output->m.name+1)='U';
*(head->output->m.name+2)='T';
*(head->output->m.name+3)='P';
*(head->output->m.name+4)='U';
*(head->output->m.name+5)='T';
*(head->output->m.name+6)=' ';
head->output->number_of_characteristics=1;
head->output->first=MACl((long int)1);
head->output->last=head->output->first;
head->output->actual=head->output->first;
head->output->first->name=0;
head->output->first->membership=0.0;
head->output->first->ahead=0;
head->output->first->follow=0;
head->output->first->set=*(head->last_Level->nodes);
return(head);
} /* ; */
Level *first_Level_highest_difference_from_neighborns(fuzzy_set *input)
/* create first Level (and its nodes for highest_difference_from_neighborns neuron type. Objects from input fuzzy sets are pointed from the first object in pair with each other object for each nodes in order (1st node:1st & 2nd; 2nd node:1st & 3rd; 3rd node:1st & 4th; etc.). Also if input fuzzy set's objects consist more than 1 characteristic characteristics are pointed in their order first from the first object than from its pair one by one zic-zac (1st object 1st characteristic, its pair object 1st characteristic, 1st object 2nd characteristic, its pair object 2nd characteristic, 1st object 3rd characteristic, its pair object 3rd characteristic, 1st object 4th characteristic, its pair object 4th characteristic, etc.). OBJECTS are assumed to HAVE THE SAME NUMBER OF characteristics ! */
{
Level *head;
int i;
head=MALe((long int)1);
head->follow=0;
head->ahead=0;
head->number_of_nodes=(input->number_of_objects<9)?input->number_of_objects-1:8;
head->Level_number=1;
head->nodes=MApFO((long int)head->number_of_nodes);
for(i=0; inumber_of_nodes; i++)
(*(head->nodes+i))=node_first_Level_highest_difference_from_neighborns(*(input->objects+0), *(input->objects+i+1));
return(head);
} /* ; */
fuzzy_object *node_first_Level_highest_difference_from_neighborns(fuzzy_object *object1, fuzzy_object *object2)
/* creates node for 1st Level of highest_difference_from_neighborns neuron type. If objects consist more than 1 characteristic characteristics are pointed in their order first from the object1 than from object2 one by one zic-zac (object1 1st characteristic, object2 1st characteristic, object1 2nd characteristic, object2 2nd characteristic, object1 3rd characteristic, object2 3rd characteristic, object1 4th characteristic, object2 4th characteristic, etc.). OBJECTS are assumet to HAVE THE SAME NUMBER OF characteristics ! */
{
fuzzy_object *head;
float *weights;
characteristic *ahead;
int i;
head=MAFO((long int)1);
head->m.name=0;
weights=MAF((long int)1);
*weights=1.0;
ahead=0;
head->number_of_characteristics=(object1->number_of_characteristicsnumber_of_characteristics)?object1->number_of_characteristics: object2->number_of_characteristics;
for(i=0, object1->actual=object1->first, object2->actual=object2->first; inumber_of_characteristics; i++)
{
head->actual=fill_weight(ahead, weights);
if(ahead==0)
head->first=head->actual;
else
ahead->follow=head->actual;
head->actual->set=(fuzzy_object*)(&(object1->actual->membership));
object1->actual=object1->actual->follow;
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->actual->set=(fuzzy_object*)(&(object2->actual->membership));
object2->actual=object2->actual->follow;
ahead=head->actual;
};
testfree((char*)weights);
return(head);
} /* ; */
void firing_highest_difference_from_neighborns(neuron *head, nucleotide_base *code)
/* calculate processing of input through neuron onto output. (First Level) node output function is pointed inside neuron's nucleide base while the last Level (only one) node output is its Maximal input. It means the function can deal with multi-layer (multi-Level) neurones whose last Level function is to find Maximum of the previous layer (Level) outputs. Common/extern float treasureholdadd variable is used for defining treasurehold and can be set using function "void treasurehold_set(float new_treasurehold)" prior to the function executing. */
{
int i;
/* calculation of nodes output propagation up to before the last Level */
for(head->actual_Level=head->first_Level; head->actual_Level!=head->last_Level; head->actual_Level=head->actual_Level->follow)
for(i=0; iactual_Level->number_of_nodes; i++)
(*(head->actual_Level->nodes+i))->m.notes=code->node_output(code->node_linear_output(*(head->actual_Level->nodes+i), head->actual_Level->Level_number));
/* calculation of the last Level's node output as Maximum of the previous Level outputs */
head->output->first->set->m.notes=Max_output_node(head->output->first->set);
head->output->first->membership=head->output->first->set->m.notes;
} /* ; */
/* corner_extractor neuron functions */
fuzzy_set **preparing_corner_extractor_neuron_population_neuron_inputs_through_window(neuron_population *np, int window_radius, int horisontal_resolution, int vertical_resolution)
/* Returns pointer on array of pointers on fuzzy sets (the same number of fuzzy sets as fuzzy objects in input fuzzy set). Prepares neuron population's neurones' input fuzzy sets from neuron population input fuzzy set presenting "picture" with dimension horisontal_resolution * vertical_resolution in a following way: each fuzzy object in neural population's input fuzzy set becomes the first fuzzy object in one and only one neuron's (inside the population) input fuzzy set, other fuzzy objects in input fuzzy set of a neuron (inside population) are fuzzy objects placed on the neuron population input "picture" inside window radius from the first object in the neuron's input (or better said placed inside square each side equal two times window radius=1 with center in the first object in neuron's input). It is similar as shifting square window (each side=2*window_radius) on the picture and inputing the central pixel as the first followed by other pixel inside window. If the window gets out of picture (means central pixel is on the edge) pixel out of picture are replaced with created fuzzy_object pointed with edge whose characteristic' memberships are all 0.0 and consists as many characteristics as input fuzzy_set's the first objects does. If neuron population has different number of neurones than its input fuzzy set unsucessful program termination is caused (exit_handling(3,1)) ! */
/* When returned array is used memory consisting data not necessary for future work should be liberate (using command testfree())! This usually means following: "for(i=0; inumber_of_neurones; testfree((char*)(*(head+i))->name), testfree((char*)(*(head+i))->objects), testfree((char*)*(head+i++))); testfree((char*)head);" after creating neuron population's neurones. */
{
int /* h, */ v,i,/* c, */ a,b;
fuzzy_set **head;
fuzzy_object* edge;
char *names;
float *memberships;
if(np->number_of_neurones!=np->input->number_of_objects) exit_handling(3,1);
if(window_radius!=1)
{
printf("\n WARNING: inside function fuzzy_set **preparing_corner_extractor_neuron_population_neuron_inputs_through_window() window_radius<>1! \n At the begining of the function is forced window_radius=1 !");
window_radius=1;
};
names=MAC((long int)2*(*(np->input->objects))->number_of_characteristics+2);
*(names+0)='0';
*(names+1)=' ';
memberships=MAF((long int)(*(np->input->objects))->number_of_characteristics);
for(v=0; v<(*(np->input->objects))->number_of_characteristics; v++)
{
*(memberships+v)=0.0;
*(names+2*v+2)='0';
*(names+2*v+3)=' ';
};
edge=set_fill((*(np->input->objects))->number_of_characteristics,names, memberships);
testfree((char*)names);
testfree((char*)memberships);
head=MApFS((long int)np->number_of_neurones);
for(i=0; inumber_of_neurones; i++)
{
*(head+i)=MAFS((long int)1);
(*(head+i))->name=MAC((long int)2);
*((*(head+i))->name+0)='I';
*((*(head+i))->name+1)=' ';
a=(int)fmod((double)i,(double)horisontal_resolution);
b=(int)floor(((double)i)/((double)horisontal_resolution));
(*(head+i))->number_of_objects=9;
(*(head+i))->objects=MApFO((long int)(*(head+i))->number_of_objects);
*((*(head+i))->objects+0)=*(np->input->objects+i);
if(a==0)
{
if(b==0)
{
for(v=1; v<5; v++)
*((*(head+i))->objects+v)=edge;
*((*(head+i))->objects+5)=*(np->input->objects+1);
*((*(head+i))->objects+6)=edge;
*((*(head+i))->objects+7)=*(np->input->objects+horisontal_resolution);
*((*(head+i))->objects+8)=*(np->input->objects+horisontal_resolution+1);
}
else if(b==vertical_resolution-1)
{
*((*(head+i))->objects+1)=edge;
*((*(head+i))->objects+2)=*(np->input->objects+i-horisontal_resolution);
*((*(head+i))->objects+3)=*(np->input->objects+i-horisontal_resolution+1);
*((*(head+i))->objects+4)=edge;
*((*(head+i))->objects+5)=*(np->input->objects+i+1);
*((*(head+i))->objects+6)=edge;
*((*(head+i))->objects+7)=edge;
*((*(head+i))->objects+8)=edge;
}
else
{
*((*(head+i))->objects+1)=edge;
*((*(head+i))->objects+2)=*(np->input->objects+i-horisontal_resolution);
*((*(head+i))->objects+3)=*(np->input->objects+i-horisontal_resolution+1);
*((*(head+i))->objects+4)=edge;
*((*(head+i))->objects+5)=*(np->input->objects+i+1);
*((*(head+i))->objects+6)=edge;
*((*(head+i))->objects+7)=*(np->input->objects+i+horisontal_resolution);
*((*(head+i))->objects+8)=*(np->input->objects+i+horisontal_resolution+1);
};
}
else if(a==horisontal_resolution-1)
{
if(b==0)
{
for(v=1; v<4; v++)
*((*(head+i))->objects+v)=edge;
*((*(head+i))->objects+4)=*(np->input->objects+i-1);
*((*(head+i))->objects+5)=edge;
*((*(head+i))->objects+6)=*(np->input->objects+i+horisontal_resolution-1);
*((*(head+i))->objects+7)=*(np->input->objects+i+horisontal_resolution);
*((*(head+i))->objects+8)=edge;
}
else if(b==vertical_resolution-1)
{
*((*(head+i))->objects+1)=*(np->input->objects+i-horisontal_resolution-1);
*((*(head+i))->objects+2)=*(np->input->objects+i-horisontal_resolution);
*((*(head+i))->objects+3)=edge;
*((*(head+i))->objects+4)=*(np->input->objects+i-1);
for(v=5; v<9; v++)
*((*(head+i))->objects+v)=edge;
}
else
{
*((*(head+i))->objects+1)=*(np->input->objects+i-horisontal_resolution-1);
*((*(head+i))->objects+2)=*(np->input->objects+i-horisontal_resolution);
*((*(head+i))->objects+3)=edge;
*((*(head+i))->objects+4)=*(np->input->objects+i-1);
*((*(head+i))->objects+5)=edge;
*((*(head+i))->objects+6)=*(np->input->objects+i+horisontal_resolution-1);
*((*(head+i))->objects+7)=*(np->input->objects+i+horisontal_resolution);
*((*(head+i))->objects+8)=edge;
};
}
else if(b==0)
{
for(v=1; v<4; v++)
*((*(head+i))->objects+v)=edge;
*((*(head+i))->objects+4)=*(np->input->objects+i-1);
*((*(head+i))->objects+5)=*(np->input->objects+i+1);
*((*(head+i))->objects+6)=*(np->input->objects+i+horisontal_resolution-1);
*((*(head+i))->objects+7)=*(np->input->objects+i+horisontal_resolution);
*((*(head+i))->objects+8)=*(np->input->objects+i+horisontal_resolution+1);
}
else if(b==vertical_resolution-1)
{
*((*(head+i))->objects+1)=*(np->input->objects+i-horisontal_resolution-1);
*((*(head+i))->objects+2)=*(np->input->objects+i-horisontal_resolution);
*((*(head+i))->objects+3)=*(np->input->objects+i-horisontal_resolution+1);
*((*(head+i))->objects+4)=*(np->input->objects+i-1);
*((*(head+i))->objects+5)=*(np->input->objects+i+1);
for(v=6; v<9; v++)
*((*(head+i))->objects+v)=edge;
}
else
{
*((*(head+i))->objects+1)=*(np->input->objects+i-horisontal_resolution-1);
*((*(head+i))->objects+2)=*(np->input->objects+i-horisontal_resolution);
*((*(head+i))->objects+3)=*(np->input->objects+i-horisontal_resolution+1);
*((*(head+i))->objects+4)=*(np->input->objects+i-1);
*((*(head+i))->objects+5)=*(np->input->objects+i+1);
*((*(head+i))->objects+6)=*(np->input->objects+i+horisontal_resolution-1);
*((*(head+i))->objects+7)=*(np->input->objects+i+horisontal_resolution);
*((*(head+i))->objects+8)=*(np->input->objects+i+horisontal_resolution+1);
};
};
return(head);
} /* ; */
neuron *create_corner_extractor(fuzzy_set *input)
/* create the neuron of corner_extractor type. Input fuzzy set (record) consists of (pointers on) fuzzy objects the first of them is the middle one in the window (dimension3*3) that is also supposed to be a peak of recognised corner while its neighborns follow. */
{
neuron *head;
fuzzy_object* *nodes_mem;
int i;
float *weights;
enum Bool check=T;
head=MAN((long int)1);
head->name=0;
head->number_of_Levels=3;
head->first_Level=first_Level_corner_extractor(input);
weights=MAF((long int)8*1);
for(i=0; i<8*1; i++)
*(weights+i)=1.0;
head->actual_Level=head->first_Level;
head->last_Level=fill_Level(2,8,1,weights,head->actual_Level); /* creates the first node in the 2nd Level receiving inputs from the first eight nodes in first Level */
head->last_Level->number_of_nodes=2;
nodes_mem=head->last_Level->nodes;
head->last_Level->nodes=MApFO((long int)2);
*(head->last_Level->nodes)=*(nodes_mem);
testfree((char*)nodes_mem);
*(head->last_Level->nodes+1)=fill_node(4,weights);
head->actual_Level->follow=head->last_Level;
for((*(head->last_Level->nodes+0))->actual=(*(head->last_Level->nodes+0))->first,i=0; i<8;(*(head->last_Level->nodes+0))->actual=(*(head->last_Level->nodes+0))->actual->follow, i++)
{
(*(head->last_Level->nodes+0))->actual->set=*(head->actual_Level->nodes+i);
if((*(head->last_Level->nodes+0))->actual==0) check=F;
};
if(check==F) exit_handling(2,3);
for((*(head->last_Level->nodes+1))->actual=(*(head->last_Level->nodes+1))->first,i=8; i<12;(*(head->last_Level->nodes+1))->actual=(*(head->last_Level->nodes+1))->actual->follow, i++)
{
(*(head->last_Level->nodes+1))->actual->set=*(head->actual_Level->nodes+i);
if((*(head->last_Level->nodes+1))->actual==0) check=F;
};
if(check==F) exit_handling(2,4);
head->actual_Level=head->last_Level;
head->last_Level=fill_Level(3,head->actual_Level->number_of_nodes,1,weights,head->actual_Level);
check=setup_weights_pointers(head->last_Level,head->actual_Level);
if(check==F) exit_handling(2,5);
head->actual_Level->follow=head->last_Level;
head->output=MAFO((long int)1);
head->output->m.name=MAC((long int)7);
*(head->output->m.name+0)='O';
*(head->output->m.name+1)='U';
*(head->output->m.name+2)='T';
*(head->output->m.name+3)='P';
*(head->output->m.name+4)='U';
*(head->output->m.name+5)='T';
*(head->output->m.name+6)=' ';
head->output->number_of_characteristics=1;
head->output->first=MACl((long int)1);
head->output->last=head->output->first;
head->output->actual=head->output->first;
head->output->first->name=0;
head->output->first->membership=0.0;
head->output->first->ahead=0;
head->output->first->follow=0;
head->output->first->set=*(head->last_Level->nodes);
return(head);
} /* ; */
Level *first_Level_corner_extractor(fuzzy_set *input)
/* create first Level (and its nodes for corner_extractor neuron type. Objects from input fuzzy sets are pointed that each node has inputs presenting rotating angles of 45, 90, and 135 degrees with corner always in central pixel (the first 8 nodes) or straight line throught the central pixel (the last 4 nodes). Also if input fuzzy set's objects consist more than 1 characteristic characteristics are pointed in their order first from the first object than from its pairs one by one (1st object 1st characteristic, second object 1st characteristic, third object 1st characteristic, 1st object 2nd characteristic, second object 2nd characteristic, third object 2nd characteristic, 1st object 3rd characteristic, second object 3rd characteristic, third object 3rd characteristic, 1st object 4th characteristic, second object 4th characteristic, third object 4th characteristic, etc.). OBJECTS are assumed to HAVE THE SAME NUMBER OF characteristics ! */
{
Level *head;
int i;
head=MALe((long int)1);
head->follow=0;
head->ahead=0;
head->number_of_nodes=12;
head->Level_number=1;
head->nodes=MApFO((long int)head->number_of_nodes);
for(i=0; inumber_of_nodes; i++)
(*(head->nodes+i))=node_first_Level_corner_extractor(i+1, input);
return(head);
} /* ; */
fuzzy_object *node_first_Level_corner_extractor(int node_number, fuzzy_set *input)
/* creates node for 1st Level of corner_extractor neuron type. Objects from input fuzzy sets are pointed that each node has inputs presenting rotating angles of 45, 90, and 135 degrees with corner always in central pixel (the first 8 nodes) or straight line throught the central pixel (the last 4 nodes). If input fuzzy set's objects consist more than 1 characteristic characteristics are pointed in their order first from the first object than from its pairs one by one (1st object 1st characteristic, second object 1st characteristic, third object 1st characteristic, 1st object 2nd characteristic, second object 2nd characteristic, third object 2nd characteristic, 1st object 3rd characteristic, second object 3rd characteristic, third object 3rd characteristic, 1st object 4th characteristic, second object 4th characteristic, third object 4th characteristic, etc. OBJECTS are assumet to HAVE THE SAME NUMBER OF characteristics ! */
/* Note node_number is node's position inside the Level and can be 1..12, but not its (pointer) position inside vector nodes that is 0..11! In fact node_number=i+1, where i is node's (pointer) place inside vector nodes for the Level. */
{
fuzzy_object *head, *object1, *object2, *object3, *object4, *object5;
float *weights;
characteristic *ahead;
int i;
if((node_number>12)||(node_number<1)) exit_handling(6,node_number);
head=MAFO((long int)1);
head->m.name=0;
weights=MAF((long int)1);
*weights=1.0;
ahead=0;
object1=*(input->objects+0);
switch(node_number)
{
case 1: object2=*(input->objects+2);
object3=*(input->objects+3);
object4=*(input->objects+5);
object5=*(input->objects+8);
break;
case 2: object2=*(input->objects+3);
object3=*(input->objects+5);
object4=*(input->objects+7);
object5=*(input->objects+8);
break;
case 3: object2=*(input->objects+5);
object3=*(input->objects+6);
object4=*(input->objects+7);
object5=*(input->objects+8);
break;
case 4: object2=*(input->objects+8);
object3=*(input->objects+4);
object4=*(input->objects+6);
object5=*(input->objects+7);
break;
case 5: object2=*(input->objects+7);
object3=*(input->objects+1);
object4=*(input->objects+4);
object5=*(input->objects+6);
break;
case 6: object2=*(input->objects+6);
object3=*(input->objects+1);
object4=*(input->objects+2);
object5=*(input->objects+4);
break;
case 7: object2=*(input->objects+4);
object3=*(input->objects+1);
object4=*(input->objects+2);
object5=*(input->objects+3);
break;
case 8: object2=*(input->objects+1);
object3=*(input->objects+2);
object4=*(input->objects+3);
object5=*(input->objects+4);
break;
case 9: object2=*(input->objects+1);
object3=*(input->objects+8);
break;
case 10: object2=*(input->objects+2);
object3=*(input->objects+7);
break;
case 11: object2=*(input->objects+3);
object3=*(input->objects+6);
break;
case 12: object2=*(input->objects+4);
object3=*(input->objects+5);
break;
default: exit_handling(6,node_number); break;
};
head->number_of_characteristics=(object1->number_of_characteristicsnumber_of_characteristics)?object1->number_of_characteristics: object2->number_of_characteristics;
if(object3->number_of_characteristicsnumber_of_characteristics) head->number_of_characteristics=object3->number_of_characteristics;
if(node_number<9)
{
if(object4->number_of_characteristicsnumber_of_characteristics) head->number_of_characteristics=object4->number_of_characteristics;
if(object5->number_of_characteristicsnumber_of_characteristics) head->number_of_characteristics=object5->number_of_characteristics;
for(i=0, object1->actual=object1->first, object2->actual=object2->first, object3->actual=object3->first, object4->actual=object4->first, object5->actual=object5->first; inumber_of_characteristics; i++)
{
head->actual=fill_weight(ahead, weights);
if(ahead==0)
head->first=head->actual;
else
ahead->follow=head->actual;
head->actual->set=(fuzzy_object*)(&(object1->actual->membership));
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->last->follow=0;
head->actual->set=(fuzzy_object*)(&(object2->actual->membership));
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->last->follow=0;
head->actual->set=(fuzzy_object*)(&(object3->actual->membership));
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->last->follow=0;
head->actual->set=(fuzzy_object*)(&(object4->actual->membership));
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->last->follow=0;
head->actual->set=(fuzzy_object*)(&(object5->actual->membership));
ahead=head->actual;
object1->actual=object1->actual->follow;
if(object2!=object1) object2->actual=object2->actual->follow;
if((object3!=object1)&&(object3!=object2)) object3->actual=object3->actual->follow;
if((object4!=object1)&&(object4!=object2)&&(object4!=object3)) object4->actual=object4->actual->follow;
if((object5!=object1)&&(object5!=object2)&&(object5!=object3)&&(object5!=object4)) object5->actual=object5->actual->follow;
};
}
else
{
for(i=0, object1->actual=object1->first, object2->actual=object2->first, object3->actual=object3->first; inumber_of_characteristics; i++)
{
head->actual=fill_weight(ahead, weights);
if(ahead==0)
head->first=head->actual;
else
ahead->follow=head->actual;
head->actual->set=(fuzzy_object*)(&(object1->actual->membership));
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->last->follow=0;
head->actual->set=(fuzzy_object*)(&(object2->actual->membership));
ahead=head->actual;
head->actual=fill_weight(ahead, weights);
ahead->follow=head->actual;
head->last=head->actual;
head->last->follow=0;
head->actual->set=(fuzzy_object*)(&(object3->actual->membership));
ahead=head->actual;
object1->actual=object1->actual->follow;
if(object2!=object1) object2->actual=object2->actual->follow;
if((object3!=object1)&&(object3!=object2)) object3->actual=object3->actual->follow;
};
};
testfree((char*)weights);
return(head);
} /* ; */
void firing_corner_extractor(neuron *head, nucleotide_base *code)
/* calculate processing of input through neuron onto output. (First Level) node output function is pointed inside neuron's nucleide base while the one before the last Level (two) node(s) output is its Maximal input. The last Level node output is n=N1*(1-N2), where n is the last Level's node output, while N1 and N2 are its inputs (the one Level's ahead of the last one nodes outputs), that means the last Level output is product of first with complement of second the Level ahead the last one nodes' output. It means the function can deal with multi-layer (multi-Level) neurones whose the one ahead the last Level function is to find Maximums of the previous layer (Level) outputs and the last Level function is n=N1*(1-N2). Common/extern float treasureholdadd variable is used for defining treasurehold and can be set using function "void treasurehold_set(float new_treasurehold)" prior to the function executing. */
/* since there are 2 group of nodes in the first Level (8+4) each of them using different (linear) output function, the second group is marked (when calling linear node output function) with negative Level number that is Level=-1*Level */
{
int i;
/* calculation of nodes output propagation up to before the last Level */
for(head->actual_Level=head->first_Level; head->actual_Level!=head->last_Level->ahead; head->actual_Level=head->actual_Level->follow)
for(i=0; iactual_Level->number_of_nodes; i++)
(*(head->actual_Level->nodes+i))->m.notes=code->node_output(code->node_linear_output(*(head->actual_Level->nodes+i), (i<8*1)?head->actual_Level->Level_number:-1*head->actual_Level->Level_number)); /* nodes higher than 8th are marked with negative Level number that is Level=-1*Level */
/* calculation of the one ahead the last Level's node output as Maximum of the previous Level outputs */
head->actual_Level=head->last_Level->ahead;
for(i=0; iactual_Level->number_of_nodes; i++)
(*(head->actual_Level->nodes+i))->m.notes=Max_output_node(*(head->actual_Level->nodes+i));
head->actual_Level=head->last_Level;
for(i=0, head->output->actual=head->output->first; iactual_Level->number_of_nodes; i++, head->output->actual=head->output->actual->follow)
{
(*(head->actual_Level->nodes+i))->m.notes=corner_extractor_last_Level_output(*(head->actual_Level->nodes+i));
head->output->actual->membership=head->output->actual->set->m.notes;
};
} /* ; */
float corner_extractor_last_Level_output(fuzzy_object *node)
/* node output is n=N1*(1-N2), where n is the last Level's node output, while N1 and N2 are its inputs. If there is more than 2 inputs into the node exit_handling(12,1) is called! */
{
float product;
product=node->first->set->m.notes*((float)1.0-node->first->follow->set->m.notes);
if(node->first->follow!=node->last) exit_handling(12,node->number_of_characteristics);
return(product);
} /* ; */
/* sort2 neuron functions */
neuron *create_sort2(fuzzy_set *input)
/* create the neuron of sort2 type. The first Level's nodes are receiving input from all input fuzzy set objects' characteristics with associated one (the one having the same number of characteristics in input fuzzy set preceding as the node having the first Level nodes preceeding) placed first. The second Level nodes are receving inputs each from all the first Level nodes. Output fuzzy object consists as many characteristics as there are nodes in the second Level (= number of nodes in the first Level = number of input fuzzy set objects' characteristics). */
/* output presents input sorted into an order! */
{
neuron *head;
characteristic *mem;
int i,j,k;
/*float *weights;
enum Bool check;*/
head=MAN((long int)1);
head->name=0;
head->number_of_Levels=2;
/* creation of the first Level */
head->first_Level=MALe((long int)1);
head->actual_Level=head->first_Level;
head->last_Level=head->first_Level;
head->first_Level->follow=0;
head->first_Level->ahead=0;
for(i=0, head->first_Level->number_of_nodes=0; inumber_of_objects; i++)
head->first_Level->number_of_nodes+=(*(input->objects+i))->number_of_characteristics;
head->first_Level->Level_number=1;
head->first_Level->nodes=MApFO((long int)head->first_Level->number_of_nodes);
for(i=0; ifirst_Level->number_of_nodes; i++)
{
*(head->first_Level->nodes+i)=MAFO((long int)1);
(*(head->first_Level->nodes+i))->number_of_characteristics=head->first_Level->number_of_nodes;
(*(head->first_Level->nodes+i))->m.notes=0.0;
(*(head->first_Level->nodes+i))->actual=0;
(*(head->first_Level->nodes+i))->first=0;
for(j=0, k=0; jnumber_of_objects; j++)
for((*(input->objects+j))->actual=(*(input->objects+j))->first; (*(input->objects+j))->actual!=0;(*(input->objects+j))->actual=(*(input->objects+j))->actual->follow, k++)
{
(*(head->first_Level->nodes+i))->last=MACl((long int)1);
if((*(head->first_Level->nodes+i))->first==0) (*(head->first_Level->nodes+i))->first=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->last->name=0;
(*(head->first_Level->nodes+i))->last->membership=1.0;
(*(head->first_Level->nodes+i))->last->set=(fuzzy_object*)(&((*(input->objects+j))->actual->membership));
(*(head->first_Level->nodes+i))->last->follow=0;
(*(head->first_Level->nodes+i))->last->ahead=(*(head->first_Level->nodes+i))->actual;
if((*(head->first_Level->nodes+i))->actual!=0) (*(head->first_Level->nodes+i))->actual->follow=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->actual=(*(head->first_Level->nodes+i))->last;
if((i==k)&&(k!=0))
{
/* associated input (characteristic) for the node is placed on the first place enabling easier calculation of the first Level output! */
mem=(*(head->first_Level->nodes+i))->first;
(*(head->first_Level->nodes+i))->first=(*(head->first_Level->nodes+i))->last;
(*(head->first_Level->nodes+i))->first->follow=mem;
(*(head->first_Level->nodes+i))->first->follow->ahead=(*(head->first_Level->nodes+i))->first;
(*(head->first_Level->nodes+i))->actual=(*(head->first_Level->nodes+i))->first->ahead;
(*(head->first_Level->nodes+i))->first->ahead=0;
(*(head->first_Level->nodes+i))->actual->follow=0;
};
};
};
/* creation of the second Level */
head->last_Level=MALe((long int)1);
head->actual_Level=head->last_Level;
head->first_Level->follow=head->last_Level;
head->last_Level->ahead=head->first_Level;
head->last_Level->number_of_nodes=head->first_Level->number_of_nodes;
head->last_Level->Level_number=2;
head->last_Level->follow=0;
head->last_Level->nodes=MApFO((long int)head->last_Level->number_of_nodes);
for(i=0; ilast_Level->number_of_nodes; i++)
{
*(head->last_Level->nodes+i)=MAFO((long int)1);
(*(head->last_Level->nodes+i))->number_of_characteristics=head->first_Level->number_of_nodes;
(*(head->last_Level->nodes+i))->m.notes=0.0;
(*(head->last_Level->nodes+i))->actual=0;
(*(head->last_Level->nodes+i))->first=0;
for(k=0; k<(*(head->last_Level->nodes+i))->number_of_characteristics; k++)
{
(*(head->last_Level->nodes+i))->last=MACl((long int)1);
if((*(head->last_Level->nodes+i))->first==0) (*(head->last_Level->nodes+i))->first=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->last->name=0;
(*(head->last_Level->nodes+i))->last->membership=1.0;
(*(head->last_Level->nodes+i))->last->set=*(head->first_Level->nodes+k);
(*(head->last_Level->nodes+i))->last->follow=0;
(*(head->last_Level->nodes+i))->last->ahead=(*(head->last_Level->nodes+i))->actual;
if((*(head->last_Level->nodes+i))->actual!=0) (*(head->last_Level->nodes+i))->actual->follow=(*(head->last_Level->nodes+i))->last;
(*(head->last_Level->nodes+i))->actual=(*(head->last_Level->nodes+i))->last;
};
};
head->output=MAFO((long int)1);
head->output->m.name=MAC((long int)7);
*(head->output->m.name+0)='O';
*(head->output->m.name+1)='U';
*(head->output->m.name+2)='T';
*(head->output->m.name+3)='P';
*(head->output->m.name+4)='U';
*(head->output->m.name+5)='T';
*(head->output->m.name+6)=' ';
head->output->number_of_characteristics=head->last_Level->number_of_nodes;
head->output->first=0;
head->output->actual=0;
for(i=0; ioutput->number_of_characteristics; i++)
{
head->output->last=MACl((long int)1);
if(head->output->first==0) head->output->first=head->output->last;
head->output->last->name=0;
head->output->last->membership=0.0;
head->output->last->set=*(head->last_Level->nodes+i);
head->output->last->ahead=head->output->actual;
head->output->last->follow=0;
if(head->output->actual!=0) head->output->actual->follow=head->output->last;
head->output->actual=head->output->last;
};
return(head);
} /* ; */
float sort2_first_Level(fuzzy_object *node, int number_of_inputs)
/* node is pointer on the node in process, while number_of_inputs is number of inputs for the node (function could be rewritten without that input, it's only included because of the requirement for 2 input values into the function, however it saves some calculation time). Output is normalised position of the first input among others. It means number of inputs higher than the first one normalised by dividing with number of inputs. */
/* Note there is no multiplication of input and associated weight ! */
{
float input1;
int i;
input1=(*((float*)(node->first->set)));
for(node->actual=node->first->follow, i=0; node->actual!=0; node->actual=node->actual->follow)
if(*((float*)(node->actual->set))>input1) i++;
return(((float)i)/((float)number_of_inputs));
} /* ; */
float sort2_second_Level(fuzzy_object *node, int node_position)
/* input into the node are all the first Level nodes' outputs. Output is input whose associated the first Level node's output (normalised value) is the highest one less or equal to normalised node position (node position/number of the first Level nodes) (number of the first Level nodes is half of number of the node's inputs). Associated input of a first Level's node is placed as its first (characteristic's) input. */
/* Note there is no multiplication of input and associated weight ! */
{
float memory=-10.0, output=0.0, np;
np=((float)node_position)/(node->number_of_characteristics);
for(node->actual=node->first; node->actual!=0; node->actual=node->actual->follow)
if(node->actual->set->m.notesactual->set->m.notes>memory)
{
memory=node->actual->set->m.notes;
output=(*((float*)(node->actual->set->first->set)));
};
return(output);
} /* ; */
void firing_sort2(neuron *head, nucleotide_base *code)
/* calculate processing of input through neuron onto output. (First Level) node output function is "sort2_first_Level()" while the last (the second one) Level nodes output function is "sort2_second_Level()". Node output function is "unchanged_linear_node_output()". It means nothing is taken from the nucleotide base but the nucleotide base remains in function call because of compatibility (can be replaced in call with "0"). Of course function can later be changed to take node output function as well as either the first or the second Level linear function from the nucleotide base. */
{
int i;
/* calculation of nodes output propagation up to before the last Level */
head->actual_Level=head->first_Level;
for(i=0; iactual_Level->number_of_nodes; i++)
(*(head->actual_Level->nodes+i))->m.notes=unchanged_linear_node_output(sort2_first_Level(*(head->actual_Level->nodes+i), head->actual_Level->number_of_nodes));
/* number of nodes in the first Level is equal to number of inputs */
head->actual_Level=head->last_Level;
for(i=0, head->output->actual=head->output->first; i