/*****************************************************************************
FUNCTION : ui_dispMapBW
PURPOSE : Program to display the MAPs of the network in black and white
NOTES :
RETURNS :
UPDATE : 22.09.94
******************************************************************************/
static void ui_displMapBW(void)
{
FlintType strength, this_x, this_y;
int xx,yy,xc=0,yc=0;
uint dx,dy;
FlintType save_act1,save_act2;
/* save unit activations */
save_act1 = krui_getUnitActivation(MAP_xUnit);
save_act2 = krui_getUnitActivation(MAP_yUnit);
/* clear the window */
XSetForeground(ui_display, MAP_GRAPH_gc[0],
BlackPixel(ui_display,MAP_GRAPH_screen));
XSetBackground(ui_display, MAP_GRAPH_gc[0],
WhitePixel(ui_display,MAP_GRAPH_screen));
XClearWindow(ui_display,MAP_GRAPH_win);
/* draw the MAP squares */
for (this_y=MAP_yMin; this_y<MAP_yMax; this_y+=MAP_scaleY) {
for (this_x=MAP_xMin; this_x<MAP_xMax; this_x+=MAP_scaleX) {
krui_setUnitActivation(MAP_xUnit, this_x);
krui_setUnitActivation(MAP_yUnit, this_y);
krui_updateNet(NULL,(int)NULL);
strength = krui_getUnitOutput(MAP_outputUnit);
dx = dy =
abs(18*(strength-MAP_minWght)/(MAP_maxWght-MAP_minWght)-9);
xx = (int)(xc*MAP_BW_squaresizeX)+20;
yy = (int)(yc*MAP_BW_squaresizeY)+20;
if(strength >(MAP_maxWght-MAP_minWght)/2 ){
XFillRectangle(ui_display,MAP_GRAPH_win,
MAP_GRAPH_gc[0],xx,yy,dx,dy);
}else{
XDrawRectangle(ui_display,MAP_GRAPH_win,
MAP_GRAPH_gc[0],xx,yy,dx,dy);
}
xc++;
}
yc++;xc=0;
}
/* restore unit activations */
krui_setUnitActivation(MAP_xUnit,save_act1);
krui_setUnitActivation(MAP_yUnit,save_act2);
/* draw the scale */
ui_map_scale(scale);
}
int snns_setUnitActivation(stEval *args, stEval *result, void *instance) {
int unitNo = STINT(&args[0]);
FlintTypeParam unitActivation = STDOUBLE(&args[1]);
krui_err errCode;
char *errMsg;
errCode = krui_setUnitActivation(unitNo, unitActivation);
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: setUnitActivation failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
void create_patterns(char *pattern_file,int no_of_exemplars)
{
FILE *fp;
float val;
int setNo;
if (!strlen(pattern_file) || !no_of_exemplars)
return; /* shortcut of no patterns */
/* create patterns with datas from pattern_file */
if((fp=fopen(pattern_file,"r"))!=NULL){
ret = krui_allocNewPatternSet(&setNo);
errChk( ret );
for (j = 1; j <= no_of_exemplars; j++){
for (i = 1; i <= IUnits; i++){
ret = krui_setCurrentUnit(i);
errChk( ret );
fscanf(fp,"%s",string);
val=atof(string);
krui_setUnitActivation(i,val);
}
ret = krui_newPattern();
errChk( ret );
}
} else {
printf("\n Pattern file %s could not be opened!\n",pattern_file);
exit(1);
}
fclose(fp);
printf("\nFilename of patterns to save: ");
scanf("%s", name);
strcat(name,".pat");
printf("Save Patterns\n");
/* save the patterns */
ret = krui_saveNewPatterns( name, setNo );
errChk( ret );
} /* end of create_patterns */
int snns_process(stEval *args, stEval *result, void *instance) {
stEvalListHead *head = STLIST(&args[0]);
float *params = (float*)STLIST(&args[1]);
int numParams = STINT(&args[2]);
FlintTypeParam *array_ptr;
double *returnarray_ptr;
double *iterator;
int quant;
int i;
int n;
int *n_ptr;
krui_err errCode;
char *errMsg;
stEvalListHead *result_head = STLIST(result);
array_ptr = list_toArray(head);
iterator = array_ptr;
quant = krui_getNoOfUnits();
i = 1;
n = 0;
for(i=1;i <= quant; i++){
if(krui_getUnitTType(i)==INPUT){
krui_setUnitActivation(i, *iterator);
iterator++;
n++;
}
}
krui_updateNet(params, numParams);
free(array_ptr); //at the moment no space is allocated in list_toArray so commenting out this will result in a delay of the seg fault.
i=0;
n=0;
for(i=1;i <= quant; i++){
if(krui_getUnitTType(i)==OUTPUT){
n++;
}
}
returnarray_ptr = slMalloc(sizeof(double)*n);
iterator = returnarray_ptr;
i=1;
for(i=1;i <= quant; i++){
if(krui_getUnitTType(i)==OUTPUT){
*iterator = krui_getUnitOutput(i);
// printf("Got output of %d\n", (*iterator));
*(iterator++);
}
}
result->values.listValue = array_toList(returnarray_ptr, n);
result->type = AT_LIST;
free(returnarray_ptr);
return EC_OK;
}
static inline void creatUnit(IPackage&p,IConnection*c)
{
uint32 subnet;
uint16 numunits;
SUnit unit,ounit;
p>>subnet>>numunits;
IPackage op("set");
op<<QString("create unit");
op<<subnet<<numunits;
int num,err;
//yet no check for subnet/layer defined, SNNS itself gives damn
//buffer for string ops:
char buf[256];
//create units
for(int i=0;i<numunits;i++){
getUnit(unit,p);
ounit=unit;
num=krui_createDefaultUnit();
if(num<0){//error
ounit.mask=UERR;
ounit.errcode=(QString)krui_error(-num);
setUnit(ounit,op);
//proceed with next unit
continue;
}else{//success
ounit.mask|=UNUM;
ounit.id=num;
}
//subnet/layer
krui_setUnitLayerNo(num,subnet&0xffff);
int subn=(subnet>>16)&0xffff;
subn-=32736;
krui_setUnitSubnetNo(num,subn);
//name
if(unit.mask&UNAME){
err=krui_setUnitName(num,CHR(buf,unit.name));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
//output function
if(unit.mask&UOUTF){
err=krui_setUnitOutFunc(num,CHR(buf,unit.outfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}//must be for error and nomask, doesn't hurt anyway
ounit.mask|=UOUTF;
ounit.outfunc=krui_getUnitOutFuncName(num);
//activation function
if(unit.mask&UACTF){
err=krui_setUnitActFunc(num,CHR(buf,unit.actfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
ounit.mask|=UACTF;
ounit.actfunc=krui_getUnitActFuncName(num);
//initial activation
if(unit.mask&UIACT)
krui_setUnitInitialActivation(num,unit.iact);
//activation
if(unit.mask&UACT)
krui_setUnitActivation(num,unit.act);
//bias
if(unit.mask&UBIAS)
krui_setUnitBias(num,unit.bias);
//prototype
if(unit.mask&UPROTO){
err=krui_setUnitFType(num,CHR(buf,unit.prototype));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.prototype=(char*)0;
//take this as non-fatal and proceed
}
}
//position
if(unit.mask&UPOS){
struct PosType pos;
pos.x=unit.xpos;
pos.y=unit.ypos;
pos.z=unit.zpos;
krui_setUnitPosition(num,&pos);
//the above doesn't transport errors, so ...
krui_getUnitPosition(num,&pos);
ounit.xpos=pos.x;
ounit.ypos=pos.y;
ounit.zpos=pos.z;
}else {
struct PosType pos;
ounit.mask|=UPOS;
krui_getUnitPosition(num,&pos);
ounit.xpos=pos.x;
ounit.ypos=pos.y;
ounit.zpos=pos.z;
}
//send back
setUnit(ounit,op);
}
c->send(op);
}
static inline void modifUnit(IPackage&p,IConnection*c)
{
uint32 subnet;
uint16 numunits;
int err;
SUnit unit,ounit;
IPackage op("set");
op<<QString("modify unit");
op<<subnet<<numunits;
char buf[256];
for(int i=0;i<numunits;i++){
getUnit(unit,p);
ounit=unit;
//check for existance
if(!(unit.mask&UNUM)){
int num=krui_createDefaultUnit();
if(num<0){
ounit.errcode="Unable to create unit.";
setUnit(ounit,op);
continue;
}
unit.id=ounit.id=num;
}
if(unit.id==0||unit.id>krui_getNoOfUnits()){
ounit.mask=UERR|UNUM;
ounit.errcode="Unit doesn't exist.";
setUnit(ounit,op);
continue;
}
//prototype
if(unit.mask&UPROTO){
err=krui_setUnitFType(unit.id,CHR(buf,unit.prototype));
if(err){
ounit.prototype=krui_getUnitFTypeName(unit.id);
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
//position
if(unit.mask&UPOS){
PosType pos;
pos.x=unit.xpos;
pos.y=unit.ypos;
pos.z=unit.zpos;
krui_setUnitPosition(unit.id,&pos);
krui_getUnitPosition(unit.id,&pos);
ounit.xpos=pos.x;
ounit.ypos=pos.y;
ounit.zpos=pos.z;
}
//bias
if(unit.mask&UBIAS){
krui_setUnitBias(unit.id,unit.bias);
}
//i_activation
if(unit.mask&UIACT){
krui_setUnitInitialActivation(unit.id,unit.iact);
}
//activation
if(unit.mask&UACT){
err=krui_setUnitActivation(unit.id,unit.act);
if(err){
ounit.act=krui_getUnitActivation(unit.id);
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
//actfunc
if(unit.mask&UACTF){
err=krui_setUnitActFunc(unit.id,CHR(buf,unit.actfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.actfunc=krui_getUnitActFuncName(unit.id);
}
}
//outfunc
if(unit.mask&UOUTF){
err=krui_setUnitOutFunc(unit.id,CHR(buf,unit.outfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.outfunc=krui_getUnitOutFuncName(unit.id);
}
}
//name
if(unit.mask&UNAME){
err=krui_setUnitName(unit.id,CHR(buf,unit.name));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.name=krui_getUnitName(unit.id);
}
}
//store
setUnit(ounit,op);
}
c->send(op);
}
