static void create_snns_unit(void)
{
struct PosType unit_pos;
PLANE *PLANE_element = PLANE_first_element;
int x,y,width,height,unit_no,pos,ret;
int y_offset=0,relative_y_max=0,absolute_y_max=0,y_begin;
int x_max=0,old_x_begin=2,new_x_begin,x_begin;
ret = krui_allocateUnits((*PLANE_last_element).width *
(*PLANE_last_element).height +
(*PLANE_last_element).begin-1);
if(ret != 0){
ui_tw_errorMessage(krui_error(ret));
BN_ERROR = 1;
}
while((! BN_ERROR) && (PLANE_element != NULL)) {
height = (*PLANE_element).height;
width = (*PLANE_element).width;
pos = (*PLANE_element).pos;
y_begin = calculate_y_begin(&absolute_y_max,&relative_y_max,&y_offset,height,pos);
x_begin = calculate_x_begin(&new_x_begin,&old_x_begin,&x_max,width,pos);
for(y=0;y<height;y++){
for(x=0;x<width;x++){
unit_no = krui_createDefaultUnit();
if(unit_no<0) ui_checkError(unit_no);
krui_setUnitActFunc(unit_no, "Act_Perceptron");
ret = krui_setUnitTType(unit_no,(*PLANE_element).type+1);
if(ret != 0){
ui_tw_errorMessage(krui_error(ret));
BN_ERROR = 1;
}
unit_pos.x = x_begin + x;
unit_pos.y = y_begin + y;
krui_setUnitPosition(unit_no,&unit_pos);
}/*for*/
}/*for*/
PLANE_element = (*PLANE_element).next;
}/*while*/
}
void errChk(int errNo )
{
if (errNo != 0)
{
printf( "%s\n", krui_error( errNo ));
exit( 1 );
}
} /* end of errChk */
int snns_setCurrentUnit(stEval *args, stEval *result, void *instance) {
int currUnit = STINT(&args[0]);
krui_err errCode;
char *errMsg;
errCode = krui_setCurrentUnit( currUnit );
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: setCurrentUnit failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
/*******************************************************************************
* snns_showPattern
*
* From the SNNS documentation:
* "According to the mode [snns_showPattern] stores the current
* pattern into the units activation (and/or output) values.
* The modes are:
* - OUTPUT_NOTHING
* store input pattern into input units activations
* - OUTPUT_ACT
* store input pattern into input units activations and
* store output pattern into output units activations
* - OUTPUT_OUT
* store input pattern into input units activations,
* store output pattern into output units activations and
* update output units output"
*
* i.e. shows a patten to the network using
* krui_showPattern
********************************************************************************/
int snns_showPattern(stEval *args, stEval *result, void *instance) {
int mode = STINT(&args[1]);
krui_err errCode;
char *errMsg;
errCode = krui_showPattern( mode );
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: setPatternNo failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
/**************************************************
* snns_setInitialisationFunc
*
* Sets the network initialization function using
* krui_setInitialisationFunc().
**************************************************/
int snns_setInitialisationFunc(stEval *args, stEval *result, void *instance) {
char *initFuncName = STSTRING(&args[0]);
krui_err errCode;
char *errMsg;
errCode = krui_setInitialisationFunc( initFuncName );
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: setInitialisationFunc failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
int snns_setUnitName(stEval *args, stEval *result, void *instance) {
char* unitName = STSTRING(&args[1]);
int unitNo = STINT(&args[0]);
krui_err errCode;
char* errMsg;
errCode = krui_setUnitName( unitNo, unitName );
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: setUnitName failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
/********************************************************************************
* snns_updateNet
*
* updates the network according to update function using
* krui_updateNet
********************************************************************************/
int snns_updateNet(stEval *args, stEval *result, void *instance) {
float *params = (float*)STLIST(&args[0]);
int numParams = STINT(&args[1]);
krui_err errCode;
char *errMsg;
errCode = krui_updateNet( params, numParams );
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: updateNet failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
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;
}
}
/**************************************************
* snns_saveNewPatterns
*
* Saves patterns from a file using
* krui_saveNewPatterns().
**************************************************/
int snns_saveNewPatterns(stEval *args, stEval *result, void *instance) {
char *filename = STSTRING(&args[0]);
int set_no = STINT(&args[1]);
krui_err errCode;
char *errMsg;
errCode = krui_saveNewPatterns(filename, set_no);
if (errCode == KRERR_NO_ERROR) {
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: saveNewPatterns failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
/**************************************************
* snns_loadNet
*
* Loads a network via the SNNS kernel UI function
* krui_loadNet().
**************************************************/
int snns_loadNet(stEval *args, stEval *result, void *instance) {
char *filename = STSTRING(&args[0]);
char *netname, *netname1;
krui_err errCode;
char *errMsg;
slMessage(0, "breveSNNS: in loadNet()");
errCode = krui_loadNet(filename, &netname);
slMessage(0, "breveSNNS: loadNet(): just finished calling krui_loadNet()");
fflush(stderr);
fflush(stdout);
netname1 = (char *)slMalloc((strlen(netname)+1) * sizeof(char));
strcpy(netname1, netname);
if(errCode == KRERR_NO_ERROR) {
STSTRING(result) = netname1;
return EC_OK;
}
else {
errMsg = krui_error(errCode);
slMessage(0, "breveSNNS: loadNet failed with message %s (error code %d).", errMsg, errCode);
return EC_ERROR;
}
}
void
ui_checkError(krui_err error)
{
if ((ui_kernelError = error) != 0)
ui_tw_errorMessage(krui_error(error));
}
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);
}
