/***************************************************************************** FILE : $Source: /projects/higgs1/SNNS/CVS/SNNS/xgui/sources/ui_controlP.c,v $ SHORTNAME : controlP.c SNNS VERSION : 4.2 PURPOSE : routines to control learning, updating the net NOTES : Most of this routines are callbacks of buttons in the control- panel. AUTHOR : Tilman Sommer DATE : 18.7.1990 CHANGED BY : Michael Vogt, Guenter Mamier RCS VERSION : $Revision: 1.58 $ LAST CHANGE : $Date: 1998/05/15 13:12:14 $ Copyright (c) 1990-1995 SNNS Group, IPVR, Univ. Stuttgart, FRG Copyright (c) 1996-1998 SNNS Group, WSI, Univ. Tuebingen, FRG ******************************************************************************/ #include #include #include #include #include #ifdef HAVE_UNISTD_H #include #endif #include "ui.h" #include "ui_mainP.h" #include "ui_utilP.h" #include "ui_selection.h" #include "ui_netUpdate.h" #include "glob_typ.h" #include "kr_ui.h" #include "ext_typ.h" #include "kr_funcs.h" #include "ui_fileP.h" #include "ui_confirmer.h" #include "ui_textP.h" #include "ui_xWidgets.h" #include "ui_display.h" #include "ui_action.h" #include "ui_control.h" #include "ui_status.h" #include "ui_infoP.h" #include "d3_main.h" #include "net_analyzer.h" #include "ui_key.h" #include "kr_typ.h" #include "cc_glob.h" #include "cc_main.h" #include "dlvq_learn.h" #include "ui_inversion.h" #include "ui_displwght.h" #include "ui_kohonen.h" #include "prun_f.h" #include "pr_main.h" #include "ui_class.h" #include "o_graph.h" #include "ui_main.h" #include "ui_event.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "ui_lists.h" #include "ui_controlP.ph" #ifdef PARAGON_KERNEL #include PARAGON_INCLUDE #include "kr_ipdef.h" #endif /***************************************************************************** FUNCTION : ui_rem_displayCounter PURPOSE : displays the value in ui_numberOfStepsDone in the control panel RETURNS : void NOTES : UPDATE : *****************************************************************************/ static void ui_rem_displayCounter (void) { char buf[50]; if (NOT ui_controlIsCreated) return; sprintf(buf,"%d", ui_numberOfStepsDone); ui_xSetLabel(ui_numberOfStepsDoneWidget, buf); } /***************************************************************************** FUNCTION : ui_rem_displayPatternNumber PURPOSE : displays the value in ui_numberOfCurrentPattern in the control panel RETURNS : void NOTES : UPDATE : 19.02.95 *****************************************************************************/ void ui_rem_displayPatternNumber (void) { char buf[50]; if (NOT ui_controlIsCreated) return; sprintf(buf,"%d", ui_noOfCurrentPattern); ui_xSetString(ui_numberOfPatternWidget, buf); ui_xSetLabel(ui_showPattFile, PATTERN_SET_FILE[CURR_PATTERN_SET]); ui_xSetLabel(ui_showTestPattFile, PATTERN_SET_FILE[CURR_TEST_PATTERN_SET]); } /***************************************************************************** FUNCTION : ui_rem_resetCounter() PURPOSE : set counter to 0 RETURNS : VOID NOTES : UPDATE : 30.7.1990 ******************************************************************************/ void ui_rem_resetCounter (void) { ui_numberOfStepsDone = 0; ui_rem_displayCounter(); } /***************************************************************************** FUNCTION : ui_rem_incCounter() PURPOSE : increment counter by 1 RETURNS : NOTES : UPDATE : 30.7.1990 ******************************************************************************/ static void ui_rem_incCounter (void) { ui_numberOfStepsDone += 1; ui_rem_displayCounter(); } /***************************************************************************** FUNCTION : ui_rem_resetNet PURPOSE : Resets the net to the initial activation and resets the counter NOTES : UPDATE : 24.8.1990 ******************************************************************************/ void ui_rem_resetNet (Widget w, XtPointer button, caddr_t call_data) { ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL); ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_ERASE); krui_resetNet(); ui_rem_resetCounter(); ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL); } /***************************************************************************** FUNCTION : ui_rem_doInitialization PURPOSE : get the parameters and call the kernel RETURNS : void NOTES : UPDATE : 19.02.95 ******************************************************************************/ void ui_rem_doInitialization (Widget w, caddr_t client_data, caddr_t call_data) { int i; char *func_name; for (i=0; i< UI_NO_INIT_PARAMS; i++) { ui_initParameters[i] = ui_xFloatFromAsciiWidget(ui_initParameterWidgets[i]); } /* check parameters for three special init functions */ func_name = krui_getInitialisationFunc(); if((strcmp(func_name,"CPN_Weights_v3.2") == 0) || (strcmp(func_name,"CPN_Weights_v3.3") == 0) || (strcmp(func_name,"KOHONEN_Weights_v3.2") == 0)){ if((ui_initParameters[0] != -1 && ui_initParameters[0] != 0 && ui_initParameters[0] != 1) || (ui_initParameters[1] != -1 && ui_initParameters[1] != 0 && ui_initParameters[1] != 1)){ ui_confirmOk("Wrong parameters given\nIntervall must be [-1,1], [-1,0], or [0,1]"); return; } } if(o_open){ o_CurveNo += ((o_CurveLengths[o_CurveNo] != 0) && (o_CurveNo < MAX_CURVE_NO-2)) ? (2) : (0); o_InitCurve(); o_LearnStepCount = 0; } ui_checkError(krui_initializeNet(ui_initParameters, UI_NO_INIT_PARAMS)); if (ui_displ_isSomeWhereToShowWeights()) ui_net_completeRefresh(NULL, UI_GLOBAL); else { ui_net_completeRefresh(NULL, UI_GLOBAL); ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); } ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL); } /***************************************************************************** FUNCTION : ui_rem_deleteNet PURPOSE : clear SNNS kernel RETURNS : void NOTES : UPDATE : 18.3.1991 ******************************************************************************/ void ui_rem_deleteNet (Widget w, caddr_t client_data, caddr_t call_data) { if (ui_confirmYes ("CLEAR: The network and all patterns will be lost. Clear?")) { /* reset kernel */ krui_deleteNet(); /* reset gui */ ui_sel_resetList(); /* reset selections */ ui_net_completeRefresh(NULL, UI_GLOBAL); /* show net */ ui_printMessage(""); ui_stat_displayStatus(ui_gridPosMouse); ui_file_updateShellLabels(); ui_info_makeUnitInfoPanelConsistent(); d3_clear_xyTranslationTable (); if (INVERS_CREATED) { XtDestroyWidget(ui_InvRootWidget); INVERS_CREATED = 0; } } } /***************************************************************************** FUNCTION : ui_rem_finishSteps PURPOSE : finish performing update steps RETURNS : void NOTES : UPDATE : 1.2.1990 ******************************************************************************/ static void ui_rem_finishSteps (void) { ui_printMessage(""); /* reshow selection markers */ ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL); } /***************************************************************************** FUNCTION : ui_rem_performStep PURPOSE : called by pressing the button STEPS RETURNS : void NOTES : UPDATE : *****************************************************************************/ static Boolean ui_rem_performStep (caddr_t client_data) { if (ui_numberOfWorkCycles-- < 1) { ui_rem_finishSteps(); if (NA_ContinueTest()) ui_rem_testProc (NULL, NULL, NULL) ; return(TRUE); } /* erase the units first, if they have to be drawn with their values in numerical form at the bottom (setup parameter) */ if (ui_displ_isSomeWhereToShowValues()) ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_ERASE_BOTTOM); ui_checkError(krui_updateNet(ui_updateParameters, UI_NO_UPDATE_PARAMS)); ui_rem_incCounter(); ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); NA_DrawNextPoint () ; return(FALSE); } /***************************************************************************** FUNCTION : ui_rem_stepsProc PURPOSE : perform one or more steps, depending on the PANEL_CLIENT_DATA if STEP is pressed one update step in the current mode if STEPS is pressed: get the number of steps to perform from the panel and go. RETURNS : void NOTES : UPDATE : *****************************************************************************/ void ui_rem_stepsProc (Widget widget, Bool multiStepPressed, caddr_t call_data) { char buf[80]; int i; if (multiStepPressed) /* MultiSTEPS button */ if ((ui_numberOfWorkCycles = ui_xIntFromAsciiWidget(ui_numberOfStepsWidget)) <= 0) return; sprintf(buf,"%d steps. Calculating ...", ui_numberOfWorkCycles); ui_printMessage(buf); for (i=0; i 0) AND (temp <= krui_getNoOfPatterns())) { ui_noOfCurrentPattern = temp; ui_rem_displayPatternNumber(); doMove = TRUE; } else ui_confirmOk("pattern goto: invalid number!"); break; case UI_FIRST: ui_noOfCurrentPattern = 1; ui_rem_displayPatternNumber(); doMove = TRUE; break; case UI_LAST: ui_noOfCurrentPattern = krui_getNoOfPatterns(); ui_rem_displayPatternNumber(); doMove = TRUE; break; case UI_NEXT: if (++ui_noOfCurrentPattern > krui_getNoOfPatterns()) ui_noOfCurrentPattern = 1; ui_rem_displayPatternNumber(); doMove = TRUE; break; case UI_PREVIOUS: if (--ui_noOfCurrentPattern < 1) ui_noOfCurrentPattern = krui_getNoOfPatterns(); ui_rem_displayPatternNumber(); doMove = TRUE; break; } if (doMove) { /* new pattern: reset */ krui_setPatternNo(ui_noOfCurrentPattern); ui_rem_getSubPatPanel(); ui_rem_resetSubPat(); ui_checkError(krui_DefShowSubPat(subIPatSize,subOPatSize, subIPatPos,subOPatPos)); ui_rem_resetCounter(); ui_checkError(krui_showPattern(ui_patternLoadMode)); ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); if(patt_info.classes){ krui_GetPatInfo(&patt_info, &descrip); sprintf(buf,"current class: %s", patt_info.class_names[descrip.my_class]); ui_xSetLabel(ui_controlMessageWidget, buf); } } } /***************************************************************************** FUNCTION : ui_rem_moveInSubPattProc PURPOSE : callback. Called when clicked on a cursor button of the supattern panel. RETURNS : void NOTES : UPDATE : *****************************************************************************/ static void ui_rem_moveInSubPattProc(Widget w, int moveParam, caddr_t call_data) { int dim, moveType; int i; pattern_set_info patt_info; pattern_descriptor descrip; char buf[3]; krui_err error; int i_temp, o_temp; int maxNpos; /* value not used */ /* Get information about current pattern set */ if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(error); return; } /* extract parameters */ dim = moveParam / 10; moveType = moveParam % 10; /* get subpattern information */ for (i=0; i< subIPatDims; i++) { subIPatSize[i] = (int)ui_xIntFromAsciiWidget(subIPatSizeW[i]); subIPatStep[i] = (int)ui_xIntFromAsciiWidget(subIPatStepW[i]); } for (i=0; i< subOPatDims; i++) { subOPatSize[i] = (int)ui_xIntFromAsciiWidget(subOPatSizeW[i]); subOPatStep[i] = (int)ui_xIntFromAsciiWidget(subOPatStepW[i]); } /* compute the new subpattern positions */ switch (moveType) { case SP_FIRST: i_temp = 1; o_temp = 1; break; case SP_LAST: i_temp = descrip.input_dim_sizes[dim] - subIPatSize[dim]+1; o_temp = descrip.output_dim_sizes[dim] - subOPatSize[dim]+1; break; case SP_NEXT: if(subIPatPos[dim]+subIPatStep[dim] <= descrip.input_dim_sizes[dim]-subIPatSize[dim]+1) i_temp = subIPatPos[dim] + subIPatStep[dim]; else i_temp = subIPatPos[dim]; if(subOPatPos[dim]+subOPatStep[dim] <= descrip.output_dim_sizes[dim]-subOPatSize[dim]+1) o_temp = subOPatPos[dim] + subOPatStep[dim]; else o_temp = subOPatPos[dim]; break; case SP_PREVIOUS: i_temp = subIPatPos[dim] - subIPatStep[dim]; if(i_temp < 1)i_temp = 1; o_temp = subOPatPos[dim] - subOPatStep[dim]; if(o_temp < 1)o_temp = 1; break; } /* perform the move */ subIPatPos[dim] = i_temp; subOPatPos[dim] = o_temp; /* validate the desired move */ ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)); ui_checkError(krui_AlignSubPat(subIPatPos,subOPatPos,&subIPatNo)); if((error = krui_DefShowSubPat(subIPatSize,subOPatSize, subIPatPos,subOPatPos)) < 0){ ui_checkError(error); return; } if((error = krui_showPattern(ui_patternLoadMode)) < 0){ ui_checkError(error); return; } ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); /* reset labels if move was successful */ for (i=0; i< subIPatDims; i++) { sprintf(buf," %d",subIPatPos[i]); ui_xSetLabel(subIPatPosW[i],buf); } for (i=0; i< subOPatDims; i++){ sprintf(buf," %d",subOPatPos[i]); ui_xSetLabel(subOPatPosW[i],buf); } } /***************************************************************************** FUNCTION : ui_rem_testProc PURPOSE : load the next (or first) pattern and perform the number of steps specified in the control panel in "no of steps" RETURNS : void NOTES : UPDATE : *****************************************************************************/ void ui_rem_testProc (Widget w, XtPointer button, caddr_t call_data) { static int npos = 1; int maxNpos; int err; char buf[50]; pattern_set_info patt_info; pattern_descriptor descrip; if (krui_getNoOfPatterns() == 0) { char buf[80]; sprintf(buf,"No patterns present."); ui_printMessage(buf); return; } /* there are patterns; get the mapping straight */ if((err = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(err); return; } if(patt_info.class_distrib_active){ if(class_readWidgets() == -1){ /* class information invalid; do not test */ return; } } if (ui_noOfCurrentPattern > krui_getNoOfPatterns() - 1) ui_noOfCurrentPattern = 0; /* set before first pattern */ /* new pattern: reset */ ui_rem_resetCounter(); ui_rem_getSubPatPanel(); ui_checkError(err = krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)); if (err != KRERR_NO_ERROR) return; ui_checkError(err = krui_AlignSubPat(subIPatPos,subOPatPos,&npos)); if (err != KRERR_NO_ERROR) return; if(++npos > maxNpos){ ui_checkError(err = krui_setPatternNo(++ui_noOfCurrentPattern)); if (err != KRERR_NO_ERROR) return; ui_checkError(err = krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)); if (err != KRERR_NO_ERROR) return; npos = 1; ui_rem_resetSubPat(); } ui_checkError(err = krui_GetShapeOfSubPattern(subIPatSize,subOPatSize, subIPatPos,subOPatPos,npos)); if (err != KRERR_NO_ERROR) return; ui_checkError(err = krui_DefShowSubPat(subIPatSize,subOPatSize, subIPatPos,subOPatPos)); if (err != KRERR_NO_ERROR) return; ui_rem_setSubPatPanel(); ui_checkError(err = krui_showPattern(ui_patternLoadMode)); if (err != KRERR_NO_ERROR) return; ui_rem_displayPatternNumber(); if (ui_xIntFromAsciiWidget(ui_numberOfStepsWidget) < 1) ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); else ui_rem_stepsProc(NULL, TRUE, NULL); /* multistep */ if(patt_info.classes){ krui_GetPatInfo(&patt_info, &descrip); sprintf(buf,"current class: %s",patt_info.class_names[descrip.my_class]); ui_xSetLabel(ui_controlMessageWidget, buf); } } /***************************************************************************** FUNCTION : ui_rem_deleteAllPatternsProc PURPOSE : delete all patterns in main memory. The contents of the current pattern file (if any) is left unchanged RETURNS : void NOTES : UPDATE : 24.8.1990 ******************************************************************************/ void ui_rem_deleteAllPatternsProc (Widget w, XtPointer button, caddr_t call_data) { if (ui_confirmYes("Delete all patterns. Are you sure?")) { krui_deleteAllPatterns(); ui_noOfCurrentPattern = 0; ui_rem_displayPatternNumber(); } } /***************************************************************************** FUNCTION : ui_rem_modifyPatternProc PURPOSE : calls the kernal in order to store the current visible pattern replacing the current pattern. RETURNS : void NOTES : UPDATE : 18.3.1991 ******************************************************************************/ void ui_rem_modifyPatternProc (Widget w, XtPointer button, caddr_t call_data) { pattern_set_info patt_info; pattern_descriptor descrip; int error; int temp = ui_xIntFromAsciiWidget(ui_numberOfPatternWidget); newPatternsLoaded = 1; if ((temp > 0) AND (temp <= krui_getNoOfPatterns())) { ui_noOfCurrentPattern = temp; krui_setPatternNo(ui_noOfCurrentPattern); ui_checkError(krui_modifyPattern()); if (ui_noOfCurrentPattern > krui_getNoOfPatterns()) { ui_noOfCurrentPattern = krui_getNoOfPatterns(); ui_rem_displayPatternNumber(); } if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(error); return; } if(patt_info.classes > 0) { ui_newClass(w, patt_info.class_names[descrip.my_class]); } } else ui_confirmOk("modify pattern: invalid pattern number!"); } /***************************************************************************** FUNCTION : ui_rem_deletePatternProc PURPOSE : calls the kernel in order to delete the current visible pattern. RETURNS : void NOTES : UPDATE : 18.3.1991 ******************************************************************************/ void ui_rem_deletePatternProc (Widget w, XtPointer button, caddr_t call_data) { int temp = ui_xIntFromAsciiWidget(ui_numberOfPatternWidget); newPatternsLoaded = 1; if ((temp > 0) AND (temp <= krui_getNoOfPatterns())) { ui_noOfCurrentPattern = temp; krui_setPatternNo(ui_noOfCurrentPattern); ui_checkError(krui_deletePattern()); if (ui_noOfCurrentPattern > krui_getNoOfPatterns()) { ui_noOfCurrentPattern = krui_getNoOfPatterns(); ui_rem_displayPatternNumber(); } krui_setPatternNo(ui_noOfCurrentPattern); ui_classUpdatePanel(FALSE); } else ui_confirmOk("delete pattern: invalid pattern number!"); } /***************************************************************************** FUNCTION : ui_rem_newPatternProc PURPOSE : calls the kernel in order to store the current visible pattern as a new one. This new pattern will be appended. RETURNS : void NOTES : UPDATE : 24.8.1990 ******************************************************************************/ void ui_rem_newPatternProc (Widget w, caddr_t call_data) { pattern_set_info patt_info; pattern_descriptor descrip; int error,setNo; bool ask = FALSE; char *classname; if(NO_OF_PATTERN_SETS == 0){ if((error = krui_allocNewPatternSet(&setNo)) < 0){ ui_checkError(error); return; } ui_noOfCurrentPattern = 1; NO_OF_PATTERN_SETS = 1; CURR_PATTERN_SET = setNo; /* set the widgets labels */ PATTERN_SET_FILE[CURR_PATTERN_SET] = (char *)malloc(8*sizeof(char)); strcpy(PATTERN_SET_FILE[CURR_PATTERN_SET],"New Set"); ui_rem_updatePattList(); ask = TRUE; classname = NULL; if((error = krui_newPattern()) < 0){ ui_checkError(error); ui_noOfCurrentPattern = 0; NO_OF_PATTERN_SETS = 0; CURR_PATTERN_SET = 0; return; } if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(error); return; } }else if(krui_getNoOfPatterns() > 0){ if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(error); return; } if(patt_info.in_number_of_dims>0 || patt_info.out_number_of_dims>0){ ui_confirmOk("NEW not allowed with variable sized patterns!"); return; } if(patt_info.classes > 0) { ask = TRUE; classname = (char *)malloc((strlen(patt_info.class_names[descrip.my_class])+1)* sizeof(char)); sprintf(classname,"%s",patt_info.class_names[descrip.my_class]); } if((error = krui_newPattern()) < 0){ ui_checkError(error); return; } if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(error); return; } } newPatternsLoaded = 1; /* for dlvq */ if(ask && (ui_kernelError == 0)) ui_newClass(w, classname); if(patt_info.classes == 0){ ui_noOfCurrentPattern = krui_getPatternNo(); ui_rem_displayPatternNumber(); } } /***************************************************************************** FUNCTION : ui_rem_printLearnInfo PURPOSE : print information about last learning cycle RETURNS : void NOTES : Kohonen requires additional information to be displayed during learning. Therefore a special section is included here. UPDATE : 23.03.94 by Sven Doering ******************************************************************************/ static void ui_rem_printLearnInfo (float *err_val) { char buf[MAX_NAME_LENGTH]; int i,j; static float temp1, temp2; static int times = 1; int pats; if(strcmp("Kohonen",krui_getLearnFunc()) == 0){ if(INIT_KOHONEN_PRINT == 1){ times = 1; INIT_KOHONEN_PRINT = 0; /* The variable is set when pressing the ALL and SINGLE Buttons in the control */ temp1 =(float)ui_xFloatFromAsciiWidget(ui_learnParameterWidgets[0]); temp2 =(float)ui_xFloatFromAsciiWidget(ui_learnParameterWidgets[1]); }else{ times = ui_numberOfLearnCycles DIV 10; } pats = krui_getNoOfPatterns(); for(j=1; j<= times; j++) for(i=1; i<=pats; i++){ /* this is a copy of the adaption process in the kernel for display reasons */ temp1 *= ui_learnParameters[2]; temp2 *= ui_learnParameters[3]; } /* Adapt the displayed values of the first two learning parameters in the control panel */ sprintf(buf,"%7.5f",temp1); strncpy(buf,buf,7); ui_xSetString(ui_learnParameterWidgets[0], buf); sprintf(buf,"%7.5f",temp2); strncpy(buf,buf,7); ui_xSetString(ui_learnParameterWidgets[1], buf); } if(ui_noErrorArrayElements != 0){ sprintf(buf,"%5d:", ui_numberOfWorkCycles + 1); ui_tw_printMessage(buf); sprintf(buf," %10.5f",err_val[0]); ui_tw_printMessage(buf); sprintf(buf," %10.5f",(err_val[0]/krui_getTotalNoOfSubPatterns())); ui_tw_printMessage(buf); if (krui_getNoOfOutputUnits() > 0) { sprintf(buf," %10.5f\n", (err_val[0]/krui_getNoOfOutputUnits())); ui_tw_printMessage(buf); } else ui_tw_printMessage("\n"); }else{ sprintf(buf," no error values available\n"); ui_tw_printMessage(buf); } } /***************************************************************************** FUNCTION : ui_rem_finishLearning PURPOSE : finish performing learning cycles RETURNS : void NOTES : UPDATE : 1.2.1990 ******************************************************************************/ static void ui_rem_finishLearning (void) { /* bring the patterns back into their old order before shuffling was done */ if (ui_shuffleFlg) ui_checkError(krui_shufflePatterns(FALSE)); if (ui_shuffleSubPatFlg) ui_checkError(krui_shuffleSubPatterns(FALSE)); if (ui_displ_isSomeWhereToShowWeights()) ui_net_completeRefresh(NULL, UI_GLOBAL); else { krui_cc_updatePosOfSpecialUnits(); ui_net_completeRefresh(NULL, UI_GLOBAL); ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW); } } /***************************************************************************** FUNCTION : ui_rem_performLearn PURPOSE : perform learning cycles RETURNS : NOTES : UPDATE : 19.02.95 ******************************************************************************/ static Boolean ui_rem_performLearn (int learnType) { krui_err err; float learn_error; static Boolean first_cycle = TRUE; static struct ErrorValuesType learn_error_values, test_error_values; dlvq_numberOfLearnCycles = ui_numberOfLearnCycles; if (ui_numberOfWorkCycles-- < 1) { ui_rem_finishLearning(); return(TRUE); } switch (learnType) { case UI_LEARN_ALL: if (ui_shuffleFlg) ui_checkError(krui_shufflePatterns(TRUE)); if (ui_shuffleSubPatFlg) ui_checkError(krui_shuffleSubPatterns(TRUE)); if (ui_jogFlg) { if (ui_jogCorrFlg) ui_checkError(krui_jogCorrWeights(jog_low, jog_high, jog_correlation)); else krui_jogWeights(jog_low, jog_high); } #ifdef PARGAGON_KERNEL if (ParallelMode) { ui_checkError(err = krip_learnAllPatterns(ui_learnParameters, UI_NO_LEARN_PARAMS +UI_NO_OF_CASCADE_PARAMS, &ui_errorArray, &ui_noErrorArrayElements, ui_numberOfLearnCycles, TRUE)); ui_numberOfWorkCycles = 0; ui_rem_finishLearning(); return (TRUE); break; } else { #endif ui_checkError(err = krui_learnAllPatterns(ui_learnParameters, UI_NO_LEARN_PARAMS +UI_NO_OF_CASCADE_PARAMS, &ui_errorArray, &ui_noErrorArrayElements)); if (err != KRERR_NO_ERROR) return (TRUE); break; #ifdef PARGAGON_KERNEL } #endif case UI_LEARN_SINGLE: #ifdef PARGAGON_KERNEL if (ParallelMode) { ui_confirmOk("Function not supported in parallel mode."); return (TRUE); } else { #endif if ((ui_noOfCurrentPattern <= krui_getNoOfPatterns()) AND (ui_noOfCurrentPattern > 0)) { ui_checkError(err = krui_learnSinglePattern(ui_noOfCurrentPattern, ui_learnParameters, UI_NO_LEARN_PARAMS +UI_NO_OF_CASCADE_PARAMS, &ui_errorArray, &ui_noErrorArrayElements)); if (err != KRERR_NO_ERROR) return (TRUE); } else ui_confirmOk("Can't learn current pattern."); #ifdef PARGAGON_KERNEL } #endif break; } ui_displWeightsFromUpdate(); if ((ui_numberOfWorkCycles == ui_numberOfLearnCycles) or (ui_numberOfWorkCycles == 0) or (ui_numberOfLearnCycles <= 10) or (((ui_numberOfWorkCycles+1) MOD (ui_numberOfLearnCycles DIV 10)) == 0)){ ui_tw_printMessage("Train"); ui_rem_printLearnInfo(ui_errorArray); } /* initialize error_values */ if (first_cycle){ test_error_values.SSE = 0.0; test_error_values.MSE = 0.0; test_error_values.SSE_div_Out = 0.0; first_cycle = FALSE; } if((ui_testFrequency > 0 ) && ((ui_numberOfWorkCycles==ui_numberOfLearnCycles-1) || (((ui_numberOfWorkCycles+1) MOD ui_testFrequency) == 0)) ) { ui_rem_performValidation(&test_error_values); ui_testError = test_error_values.SSE; } if(o_open){ learn_error = ui_errorArray[0]; learn_error_values.SSE = learn_error; learn_error_values.MSE = learn_error / (float) krui_getTotalNoOfSubPatterns(); learn_error_values.SSE_div_Out = learn_error / (float) krui_getNoOfOutputUnits(); o_draw(learn_error_values, test_error_values,ui_testFrequency); if(ui_numberOfWorkCycles == 0){ o_PressPossible = 1; } } return(FALSE); } /***************************************************************************** FUNCTION : ui_rem_performValidate PURPOSE : perform validation of training run (only used as Callback-Func) RETURNS : NOTES : UPDATE : 22.06.95 ******************************************************************************/ void ui_rem_performValidate(caddr_t call_data) { struct ErrorValuesType test_error_values; if(!strcmp(krui_getLearnFunc(),"PruningFeedForward")) /* necessary to get the pruning parameters straight */ krui_setFFLearnFunc (krf_getCurrentNetworkFunc (FF_LEARN_FUNC | LEARN_FUNC)); ui_rem_performValidation(&test_error_values); return; } /***************************************************************************** FUNCTION : ui_rem_performValidation PURPOSE : perform validation of training run RETURNS : NOTES : UPDATE : 26.06.95 ******************************************************************************/ void ui_rem_performValidation(struct ErrorValuesType *test_error_values) { int err; int maxNpos; /* switch to the validation set */ if((err = krui_setCurrPatSet(CURR_TEST_PATTERN_SET)) < 0){ ui_checkError(err); return /* (TRUE) */; } ui_rem_getSubPatPanel(); ui_rem_resetSubPat(); if (ui_shuffleFlg) ui_checkError(krui_shufflePatterns(TRUE)); if (ui_shuffleSubPatFlg) ui_checkError(krui_shuffleSubPatterns(TRUE)); ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)); ui_checkError(err = krui_testAllPatterns(ui_learnParameters, UI_NO_LEARN_PARAMS +UI_NO_OF_CASCADE_PARAMS, &ui_testArray, &ui_noTestArrayElements)); if (err != KRERR_NO_ERROR){ ui_testFrequency = 0; }else{ if((ui_numberOfWorkCycles == ui_numberOfLearnCycles) or (ui_numberOfWorkCycles == 0) or (ui_testFrequency == 0) or ((((ui_numberOfLearnCycles+1)DIV ui_testFrequency)DIV 10)==0) or ((((ui_numberOfWorkCycles+1) DIV ui_testFrequency) MOD (((ui_numberOfLearnCycles+1)DIV ui_testFrequency)DIV 10))==0)){ ui_tw_printMessage("Test "); ui_rem_printLearnInfo(ui_testArray); } } test_error_values->SSE = ui_testArray[0]; test_error_values->MSE = ui_testArray[0] / (float) krui_getTotalNoOfSubPatterns(); test_error_values->SSE_div_Out = ui_testArray[0] / (float) krui_getNoOfOutputUnits(); /* switch back to the training pattern set */ if((err = krui_setCurrPatSet(CURR_PATTERN_SET)) < 0){ ui_checkError(err); return /*(TRUE)*/; } ui_rem_getSubPatPanel (); ui_rem_resetSubPat(); ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)); /* return to caller */ return; } /***************************************************************************** FUNCTION : ui_rem_performPrunInit PURPOSE : perform pruning: first training, initialization RETURNS : NOTES : UPDATE : ******************************************************************************/ static Boolean ui_rem_performPrunInit (int learnType) { float net_error; /* create temporary file */ tmp_file = tempnam ("./","SNNS_"); /* display message */ ui_tw_printMessage (" -------------------- first training --------------------\n"); /* train network into minimum */ net_error = ui_rem_performFFLearn (pr_trainCycles, learnType); if (net_error >= 0) /* no error occured during training */ { /* store maximum error */ if (net_error < pr_minError) net_error = pr_minError; pr_maxError = net_error * (1 + pr_maxErrorInc / 100); if (pr_maxError < pr_acceptedError) pr_maxError = pr_acceptedError; /* call pruning work procedure */ ui_workProcId = XtAppAddWorkProc (ui_appContext, (XtWorkProc) ui_rem_performPrun, (XtPointer) ((long)learnType)); } /* remove this work procedure */ return (TRUE); } /***************************************************************************** FUNCTION : ui_rem_performPrun PURPOSE : perform pruning: prune link and retrain RETURNS : NOTES : UPDATE : ******************************************************************************/ static Boolean ui_rem_performPrun (int learnType) { float net_error; krui_err err; char *dummy_str; if (pr_recreate) { /* display message */ ui_tw_printMessage (" ---------------------- saving net ----------------------\n"); /* save net */ krui_saveNet (tmp_file, "Pruned Net"); } /* display message */ ui_tw_printMessage (" ----------------------- pruning ------------------------\n\n"); /* delete some weight */ switch (learnType) { case UI_LEARN_ALL: err = pr_callPrunFunc (PR_ALL_PATTERNS); break; case UI_LEARN_SINGLE: err = pr_callPrunFunc (ui_noOfCurrentPattern); break; } if (err != KRERR_NO_ERROR) /* remove this work procedure */ return (TRUE); err = pr_calcMeanDeviation (PR_ALL_PATTERNS, &net_error); if (err != KRERR_NO_ERROR) return (TRUE); if (net_error > pr_minError) { /* update display after pruning */ if(pr_refresh) ui_net_completeRefresh(NULL, UI_GLOBAL); /* display message */ ui_tw_printMessage (" ---------------------- retraining ----------------------\n"); /* retrain network */ net_error = ui_rem_performFFLearn (pr_retrainCycles, learnType); if (net_error < 0) /* remove this work procedure */ return (TRUE); } if (net_error > pr_maxError) /* error is beyond maximum */ { if (pr_recreate) { /* display message */ ui_tw_printMessage (" -------------------- reloading net --------------------\n"); /* reload last saved net */ krui_loadNet (tmp_file, &dummy_str); /* delete temporary file */ unlink (tmp_file); } /* display message */ ui_tw_printMessage (" -------------------- end of pruning --------------------\n"); /* remove this work procedure */ return (TRUE); } else /* this work procedure stays registered */ return (FALSE); } /***************************************************************************** FUNCTION : ui_rem_errProc PURPOSE : get Net Error NOTES : Thanks to Warren Sarle ! A good reference is: . Judge, G.G et al. _The Theory and Practice of Econometrics_, . New York: John Wiley & Sons, 1980 RETURNS : void UPDATE : *****************************************************************************/ void ui_rem_errProc (Widget w, XtPointer button, caddr_t call_data) { float sse=0,tss,rsq=0,adjrsq=0,mse=0,rmse=0,J_p=0,gcv=0; float pc=0,S_p=0,gmsep=0,shibata=0,aic=0,sbc=0; float *errorArray, learnParams[2]={0,0}; int p,n,noErrorArrayElements, noLearnParams=2; char *learnFunc=krui_getLearnFunc(); int maxNpos; /*Not used */ krui_err err; /* number of observations */ if(!(n=krui_getNoOfPatterns() )) { ui_confirmOk("sample size is 0, giving up"); return; } printf("--------------------- s t a t i s t i c s-------------------------------------\n"); printf("Number of Patterns : %10i\n",n); /* number of parameters including intercept */ if(!(p=krui_countLinks())) { ui_confirmOk("number of parameters is 0, giving up"); return; } printf("Number of parameters (Links+bias)\t : %10i\n",p); if( krui_setLearnFunc("Std_Backpropagation")!=KRERR_NO_ERROR) { ui_confirmOk("Can't change Learningfunktion to Std_Backpropagation, giving up"); return; } if( (err = krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)) !=KRERR_NO_ERROR){ ui_checkError(err); krui_setLearnFunc(learnFunc); return; } if( (err=krui_learnAllPatterns(learnParams,noLearnParams,&errorArray, &noErrorArrayElements)) != KRERR_NO_ERROR) { ui_checkError(err); krui_setLearnFunc(learnFunc); return; } sse=errorArray[0]; printf("sse\t\t : %10.4f\n",sse); krui_setLearnFunc(learnFunc); /* total sum of squares corrected for the mean for the dependent * var(s) */ tss = krui_getVariance()*n; printf("tss\t\t : %10.4f\n",tss); /* sigma^2: an estimate of the pure error variance, usually pbtained * from replicated observations or by fitting the model with all * predictors */ /* if(n!=1) * sigma = (sse - ((sigma*sigma)/n)) / (n-1); */ /* rsq: the propotion of variance explained by the model */ if(tss) rsq = 1 - sse/tss; printf("rsq\t\t : %10.4f\n",rsq); /* mse: the mean square error (Darlington 1968) */ if(n-p>0){ mse = sse / (n-p); printf("mse\t\t : %10.4f\n",mse); }else printf("mse\t\t : sample size to small, mse not computed \n"); /* rmse: the root mean square error */ rmse = (float) sqrt((double)mse); printf("rmse\t\t : %10.4f\n",rmse); /* adjrsq: rsq adjusted for degrees of freedom */ if(n-p>0){ adjrsq = 1-((float)(n-1)/(n-p))*(1-rsq); printf("adjrsq\t\t : %10.4f\n",adjrsq); }else printf("adjrsq\t\t : sample size to small, adjrsq not computed\n"); /* J_p: the estimated mean square error of prediction assuming that * the values of the regressors are fixed and that the model is * correct */ J_p = (n+p) * mse / n; printf("J_p\t\t : %10.4f\n",J_p); /* gcv: the generalized crossvalidation statistic */ if(n-p>0){ gcv = (sse * n) / ((n-p)*(n-p)); printf("gcv\t\t : %10.4f\n",gcv); }else printf("gcv\t\t : sample size to small, gvc not computed\n"); /* pc: Amemiya's prediction criterion */ if(n-p>0){ pc = 1-((float)(n+p)/(n-p))*(1-rsq); printf("pc\t\t : %10.4f\n",pc); }else printf("pc\t\t : sample size to small, pc not computed\n"); /* C_p: Mallow's C_p statistic */ /* if(sigma) * C_p = (sse/sigma) + 2*p-n; * else * printf("Note: sigma is 0, C_p not computed\n"); */ /* S_p: the S_p statistic (Hocking 1976) */ if(n-p-1>0){ S_p = mse / (n-p-1); printf("S_p\t\t : %10.4f\n",S_p); }else printf("S_p\t\t : sample size to small, S_p not computed\n"); /* gmsep the estimated mean square error of prediction assuming that * both independent and dependent vars are multivariate normal * (Stein 1960) */ if(n-p-1>0){ gmsep = mse*(n+1)*(n-1) / (n*(n-p-1)); printf("gmsep\t\t : %10.4f\n",gmsep); }else printf("gmsep\t\t : sample size to small, gmsep not computed\n"); /* shibata: Shibata 1960 */ shibata = sse*(n+2*p)/n; printf("shibata\t\t : %10.4f\n",shibata); /* aic: Akaikes information criterion (Akaike 1960) */ aic = n* ((float)log((double)(sse/n))) + 2*p; printf("aic\t\t : %10.4f\n",aic); /* sbc: Schwarz's Bayesian criterion (Schwarz 1978) */ sbc = n* ((float)log((double)(sse/n))) + p*((float)log((double)n)); printf("sbc\t\t : %10.4f\n",sbc); /* bic: Sawa's Bayesian information criterion (Sawa 1978) */ /* if(sse) { * q = sigma / (sse/n); * bic = n* ((float)log((double)(sse/n))) + 2*(p+2)*q-2*(q*q); * } else { * printf("Note: sse is 0, bic not computed\n"); * } */ printf("------------------------------------------------------------------------------\n"); return; } #ifdef _UNUSED_FUNCTIONS_ /***************************************************************************** FUNCTION : ui_sGamma PURPOSE : gamma function, note that this works only for x%2 == 0||0.5 *****************************************************************************/ static double ui_sGamma (double x) { double ret=1; if(x-(int)x) { ret=0.88623; } while(x>2) { x--; ret*=x; } return ret; } /***************************************************************************** FUNCTION : ui_sFisherDis PURPOSE : numerical intergration of the Fisher density function *****************************************************************************/ static double ui_sFisherDis(double m, double n, double x, double accuracy) { double f; double result=0,foo=1./accuracy; double sepp=x*accuracy*ui_sGamma(m/2.)*ui_sGamma(n/2.)/\ (ui_sGamma((m+n)/2.)*pow(m,m/2.)*pow(n,n/2.)); for(f=0;result= 0; ui_numberOfWorkCycles--) { /* shuffle patterns */ if (ui_shuffleFlg) ui_checkError (krui_shufflePatterns (TRUE)); if (ui_shuffleSubPatFlg) ui_checkError (krui_shuffleSubPatterns (TRUE)); /* perform one learn cycle */ ui_checkError (err = krui_learnAllPatternsFF (ui_learnParameters, UI_NO_LEARN_PARAMS, &ui_errorArray, &ui_noErrorArrayElements)); if (err != KRERR_NO_ERROR) return (err); /* print information periodically */ if ((ui_numberOfWorkCycles == cycles) || (ui_numberOfWorkCycles == 0) ||(cycles <= 10) || (((ui_numberOfWorkCycles+1) MOD (cycles DIV 10)) == 0)) { ui_tw_printMessage(" "); /* This dummy is necessary for alignment reasons */ ui_rem_printLearnInfo(ui_errorArray); ui_displWeightsFromUpdate(); } /* print error graph */ if (o_open){ learn_error_values.SSE = ui_errorArray[0]; learn_error_values.MSE = ui_errorArray[0] / (float) krui_getTotalNoOfSubPatterns(); learn_error_values.SSE_div_Out = ui_errorArray[0] / (float) krui_getNoOfOutputUnits(); test_error_values.SSE = 0.0; test_error_values.MSE = 0.0; test_error_values.SSE_div_Out = 0.0; o_draw (learn_error_values, test_error_values,0); } /* stop learning if error is smaller than minimum */ if (ui_errorArray [0] <= pr_minError) break; } o_PressPossible = 1; /* ui_checkError (err = krui_testAllPatterns (ui_learnParameters, UI_NO_LEARN_PARAMS, &ui_errorArray, &ui_noErrorArrayElements)); if (err != KRERR_NO_ERROR) return (err); */ break; case UI_LEARN_SINGLE: for (ui_numberOfWorkCycles = cycles - 1; ui_numberOfWorkCycles >= 0; ui_numberOfWorkCycles--) { /* perform one learn cycle */ ui_checkError (err = krui_learnSinglePatternFF (ui_noOfCurrentPattern, ui_learnParameters, UI_NO_LEARN_PARAMS, &ui_errorArray, &ui_noErrorArrayElements)); if (err != KRERR_NO_ERROR) return (err); /* print information periodically */ if ((ui_numberOfWorkCycles == cycles) || (ui_numberOfWorkCycles == 0) ||(cycles <= 10) || (((ui_numberOfWorkCycles+1) MOD (cycles DIV 10)) == 0)) { ui_rem_printLearnInfo(ui_errorArray); ui_displWeightsFromUpdate(); } /* print error graph */ if (o_open){ learn_error_values.SSE = ui_errorArray[0]; learn_error_values.MSE = ui_errorArray[0] / (float) krui_getTotalNoOfSubPatterns(); learn_error_values.SSE_div_Out = ui_errorArray[0] / (float) krui_getNoOfOutputUnits(); test_error_values.SSE = 0.0; test_error_values.MSE = 0.0; test_error_values.SSE_div_Out = 0.0; o_draw (learn_error_values, test_error_values,0); } /* stop learning if error is smaller than minimum */ if (ui_errorArray [0] <= pr_minError) break; } o_PressPossible = 1; ui_checkError (err = krui_testSinglePattern (ui_noOfCurrentPattern, ui_learnParameters, UI_NO_LEARN_PARAMS, &ui_errorArray, &ui_noErrorArrayElements)); if (err != KRERR_NO_ERROR) return (err); break; } return (ui_errorArray [0]); } /***************************************************************************** FUNCTION : ui_rem_learnProc PURPOSE : call the learn procedure of the kernel. The number of learn cycles is determined by the user and also the learn parameter. RETURNS : implicite alteration of the network NOTES : UPDATE : 19.02.95 *****************************************************************************/ void ui_rem_learnProc (Widget w, int learnType, caddr_t call_data) { char buf[MAX_NAME_LENGTH]; int i, maxNpos, error; pattern_set_info patt_info; pattern_descriptor descrip; o_PressPossible = 0; cc_readElements(); cc_allButtonIsPressed = 1; pr_readElements(); /* check now for errors and react ! */ if (krui_getNoOfPatterns() == 0) { ui_confirmOk("No patterns loaded/created!"); return; } ui_rem_getSubPatPanel (); ui_rem_resetSubPat(); ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize, subIPatStep,subOPatStep,&maxNpos)); ui_testFrequency = ui_xIntFromAsciiWidget(ui_testFrequencyWidget); ui_testFrequency = (ui_testFrequency < 1) ? (0) : ui_testFrequency; ui_testError = 0; ui_numberOfWorkCycles = /* this value will be decreased */ ui_xIntFromAsciiWidget(ui_numberOfCyclesWidget); ui_numberOfLearnCycles = /* this value stays constant */ ui_numberOfWorkCycles; /* get current learning parameter */ for (i=0; i high) { temp = low; low = high; high = temp; } corr = fabs(corr); switch (randomType) { case UI_RANDOM: /* krui_randomizeWeights(low, high); */ break; case UI_JOG: if (ui_jogCorrFlg) ui_checkError(krui_jogCorrWeights(low, high, corr)); else krui_jogWeights(low, high); break; } if (ui_displ_isSomeWhereToShowWeights()) ui_net_completeRefresh(NULL, UI_GLOBAL); } /***************************************************************************** FUNCTION : ui_rem_getKernelInfo PURPOSE : get some info from the kernel. Output to text window RETURNS : void NOTES : UPDATE : 1.2.1990 ******************************************************************************/ void ui_rem_getKernelInfo (Widget w, XtPointer button, caddr_t call_data) { char buf[127]; int no_of_sites, no_of_links, no_of_STable_entries, no_of_FTable_entries; int unit_bytes, site_bytes, link_bytes, NTable_bytes, STable_bytes, FTable_bytes, numOfPat, ui_totNumOfPat; pattern_set_info patt_info; pattern_descriptor descrip; if(krui_GetPatInfo(&patt_info, &descrip) != KRERR_NO_ERROR){ patt_info.class_distrib_active = FALSE; patt_info.remap_function = NULL; } /* check the class information */ if(patt_info.class_distrib_active){ if(class_readWidgets() == -1){ /* class information invalid; do not move */ ui_confirmOk("Class distribution invalid!"); return; } } if((numOfPat = krui_getNoOfPatterns()) < 0){ numOfPat = 0; ui_totNumOfPat = 0; }else{ ui_rem_getSubPatPanel (); ui_rem_resetSubPat(); ui_totNumOfPat = krui_getTotalNoOfSubPatterns(); } sprintf(buf,"\n%s :\n\n", krui_getVersion()); ui_tw_printMessage(buf); krui_getNetInfo(&no_of_sites, &no_of_links, &no_of_STable_entries, &no_of_FTable_entries); sprintf(buf,"#input units: %6d\n#output units: %6d\n", krui_getNoOfInputUnits(), krui_getNoOfOutputUnits()); ui_tw_printMessage(buf); sprintf(buf,"#patterns : %6d\n",numOfPat); ui_tw_printMessage(buf); sprintf(buf,"#subpatterns : %6d\n",ui_totNumOfPat); ui_tw_printMessage(buf); sprintf(buf,"#sites : %6d\n#links : %6d\n", no_of_sites, no_of_links); ui_tw_printMessage(buf); sprintf(buf,"#STable entr.: %6d\n#FTable-Entr.: %6d\n\n", no_of_STable_entries, no_of_FTable_entries); ui_tw_printMessage(buf); ui_tw_printMessage("sizes in bytes:\n"); krui_getMemoryManagerInfo(&unit_bytes, &site_bytes, &link_bytes, &NTable_bytes, &STable_bytes, &FTable_bytes); sprintf(buf,"units : %7d\nsites : %7d\nlinks : %7d\n", unit_bytes, site_bytes, link_bytes); ui_tw_printMessage(buf); sprintf(buf,"NTable : %7d\nSTable : %7d\nFTable : %7d\n\n" ,NTable_bytes, STable_bytes, FTable_bytes); ui_tw_printMessage(buf); sprintf(buf,"learning function : %s\n", krui_getLearnFunc()); ui_tw_printMessage(buf); sprintf(buf,"update function : %s\n", krui_getUpdateFunc()); ui_tw_printMessage(buf); sprintf(buf,"init function : %s\n", krui_getInitialisationFunc()); ui_tw_printMessage(buf); if(patt_info.remap_function == NULL) sprintf(buf,"remap function : None\n"); else sprintf(buf,"remap function : %s\n", patt_info.remap_function); ui_tw_printMessage(buf); if(ui_filenameNET[0] != '\0'){ sprintf(buf,"network file : %s.net\n",ui_filenameNET); ui_tw_printMessage(buf); }else{ sprintf(buf,"No Network loaded\n"); ui_tw_printMessage(buf); } if(numOfPat > 0){ sprintf(buf,"learn pattern file : %s.pat\n", PATTERN_SET_FILE[CURR_PATTERN_SET]); ui_tw_printMessage(buf); sprintf(buf,"test pattern file : %s.pat\n", PATTERN_SET_FILE[CURR_TEST_PATTERN_SET]); ui_tw_printMessage(buf); }else{ sprintf(buf,"No Patterns loaded\n"); ui_tw_printMessage(buf); } ui_tw_printMessage("\n\n"); } /***************************************************************************** FUNCTION : ui_rem_shuffleSubPatProc PURPOSE : notify procedure of the toggle item, to remember the status of it. RETURNS : changes the flag ui_shuffleSubPatFlg NOTES : UPDATE : *****************************************************************************/ void ui_rem_shuffleSubPatProc (Widget w, caddr_t client, caddr_t call) { ui_shuffleSubPatFlg = ui_xGetToggleState(w); } /***************************************************************************** FUNCTION : ui_rem_defSubPat PURPOSE : creates the panel to handle sub patterns RETURNS : void NOTES : UPDATE : 16.09.1993 ******************************************************************************/ void ui_rem_defSubPat (Widget button, int refreshType, caddr_t call_data) { Widget sbutton,lab1,ui_pop,above, isize,istep,itot,otot,osize,ostep; static Widget form,title1,title2,left,subPatDoneW, input,output,ipos,opos; Arg args[5]; Position x, y; Dimension width, height; Cardinal n; char buf[120]; int i; krui_err error; pattern_set_info patt_info; pattern_descriptor descrip; Window rdummy; int x1, y1, border; unsigned int wdummy, hdummy, bdummy, ddummy; /* Get information about current pattern set */ if(NO_OF_PATTERN_SETS == 0){ if(refreshType == 0){ ui_confirmOk("No Patterns present !"); return; }else{ /* call came from ui_rem_delPatSet which deleted last pattern */ /* set. Therefore destroy panel */ XtCallCallbacks(subPatDoneW,XtNcallback, (caddr_t) UI_POPUP_SUBPATTERN); return; } } if((refreshType == 1) && (SubPatPanel < 1)) /* can't refresh, if panel was never created yet */ return; if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){ ui_checkError(error); return; } if(patt_info.in_number_of_dims == 0){ if(SubPatPanel < 1){ ui_confirmOk("Pattern has no variable dimension !"); return; }else{ /* New pattern set does not allow this panel */ XtCallCallbacks(subPatDoneW,XtNcallback, (caddr_t) UI_POPUP_SUBPATTERN); return; } } if(refreshType == 0){ /*panel has to be created */ if(SubPatPanel == 1) /* panel was supposed to be created but exists already */ return; /* Upper left corner will be in the center of the calling button */ ui_xGetDimensions(button, &width, &height); XtTranslateCoords(button, (Position) (width / 2), (Position) (height / 2),&x, &y); n = 0; XtSetArg(args[n], XtNx, x); n++; XtSetArg(args[n], XtNy, y); n++; /* Now create Popup */ ui_popPattern = XtCreatePopupShell("Sub Pattern Handling", topLevelShellWidgetClass,ui_toplevel,args,n); }else{ /* Recreate the panel */ n = 0; XtSetArg(args[n], XtNx, &x); n++; XtSetArg(args[n], XtNy, &y); n++; XtSetArg(args[n], XtNborderWidth, &border); n++; XtGetValues(ui_popPattern, args, n); XGetGeometry(ui_display, (*ui_popPattern).core.window, &rdummy, &x1, &y1, &wdummy, &hdummy, &bdummy, &ddummy); XtDestroyWidget(ui_popPattern); n = 0; XtSetArg(args[n], XtNx, x-x1-bdummy-1); n++; XtSetArg(args[n], XtNy, y-y1-bdummy-1); n++; ui_popPattern = XtCreatePopupShell("Sub Pattern Handling", transientShellWidgetClass,ui_toplevel,args,n); } ui_pop = XtCreateManagedWidget("frame",formWidgetClass,ui_popPattern, NULL,0); XtSetArg(args[n], XtNborderWidth, 1); form = XtCreateManagedWidget("form", formWidgetClass, ui_pop, args, 1); sprintf(buf," Input"); title1 = ui_xCreateLabelItem(buf,form,41*ui_labelFontWidth,NULL,NULL); sprintf(buf," Output"); title2 = ui_xCreateLabelItem(buf,form,14*ui_labelFontWidth,title1,NULL); n = 0; XtSetArg(args[n], XtNborderWidth, 0); n++; XtSetArg(args[n], XtNfromHoriz, NULL); n++; XtSetArg(args[n], XtNfromVert, title1); n++; left = XtCreateManagedWidget("left", formWidgetClass, form, args, n); sprintf(buf," "); title1 = ui_xCreateLabelItem(buf,left,9*ui_labelFontWidth,NULL,NULL); sbutton = ui_xCreateToggleItem("shuffle", left, NULL, title1, NULL); XtAddCallback(sbutton, XtNcallback, (XtCallbackProc) ui_rem_shuffleSubPatProc, NULL); subIPatDims = patt_info.in_number_of_dims; subOPatDims = patt_info.out_number_of_dims; above = sbutton; for (i=0; i< subIPatDims; i++) { sprintf(buf,"dim %d :",i+1); lab1 = ui_xCreateLabelItem(buf, left, 7*ui_labelFontWidth, NULL, above); sbutton = ui_xCreateButtonItem("first",left,lab1,above); XtAddCallback(sbutton, XtNcallback, (XtCallbackProc)ui_rem_moveInSubPattProc, (XtPointer) ((long)(SP_FIRST + i*10))); sbutton = ui_xCreateButtonItem("prev",left, sbutton, above); XtAddCallback(sbutton, XtNcallback, (XtCallbackProc)ui_rem_moveInSubPattProc, (XtPointer) ((long)(SP_PREVIOUS + i*10))); sbutton = ui_xCreateButtonItem("next",left, sbutton, above); XtAddCallback(sbutton, XtNcallback, (XtCallbackProc) ui_rem_moveInSubPattProc, (XtPointer) ((long)(SP_NEXT + i*10))); sbutton = ui_xCreateButtonItem("last",left, sbutton, above); XtAddCallback(sbutton, XtNcallback, (XtCallbackProc) ui_rem_moveInSubPattProc, (XtPointer) ((long)(SP_LAST + i*10))); above = lab1; } n = 0; XtSetArg(args[n], XtNborderWidth, 1); n++; XtSetArg(args[n], XtNfromHoriz, left); n++; XtSetArg(args[n], XtNfromVert, title1); n++; input = XtCreateManagedWidget("input", formWidgetClass, form, args, n); ipos = ui_xCreateLabelItem("Pos ",input,4*ui_labelFontWidth,NULL,NULL); itot = ui_xCreateLabelItem("Tot ",input,4*ui_labelFontWidth,ipos,NULL); isize = ui_xCreateLabelItem("Size",input,4*ui_labelFontWidth,itot,NULL); istep = ui_xCreateLabelItem("Step",input,4*ui_labelFontWidth,isize,NULL); above = ipos; for (i=0; i< subIPatDims; i++) { sprintf(buf," %d",subIPatPos[i]); subIPatPosW[i] = ui_xCreateLabelItem(buf,input,4*ui_labelFontWidth, NULL,above); sprintf(buf," %d",descrip.input_dim_sizes[i]); in_dim_widgets[i] = ui_xCreateLabelItem(buf,input,5*ui_labelFontWidth, subIPatPosW[i],above); sprintf(buf,"%d",subIPatSize[i]); subIPatSizeW[i] = ui_xCreateDialogItem("param",input,buf, 4*ui_labelFontWidth, in_dim_widgets[i],above); sprintf(buf,"%d",subIPatStep[i]); subIPatStepW[i] = ui_xCreateDialogItem("param",input,buf, 4*ui_labelFontWidth, subIPatSizeW[i],above); above = subIPatPosW[i]; } n = 0; XtSetArg(args[n], XtNborderWidth, 1); n++; XtSetArg(args[n], XtNfromHoriz, input); n++; XtSetArg(args[n], XtNfromVert, title2); n++; output = XtCreateManagedWidget("output",formWidgetClass,form,args,n); opos = ui_xCreateLabelItem("Pos ",output,4*ui_labelFontWidth,NULL,NULL); otot = ui_xCreateLabelItem("Tot ",output,4*ui_labelFontWidth,opos,NULL); osize = ui_xCreateLabelItem("Size",output,4*ui_labelFontWidth,otot,NULL); ostep = ui_xCreateLabelItem("Step",output,4*ui_labelFontWidth,osize,NULL); above = opos; for (i=0; i= setNo) CURR_TEST_PATTERN_SET--; sprintf(buf,"%s",PATTERN_SET_FILE[CURR_TEST_PATTERN_SET]); ui_xSetLabel(ui_showTestPattFile, buf); /* destroy the widgets corresponding to the deleted pattern */ if(NO_OF_PATTERN_SETS > 0){ XtRemoveAllCallbacks(USEPattFileWidget[NO_OF_PATTERN_SETS],XtNcallback); XtRemoveAllCallbacks(USETestPattFileWidget[NO_OF_PATTERN_SETS],XtNcallback); XtRemoveAllCallbacks(DELPattFileWidget[NO_OF_PATTERN_SETS],XtNcallback); XtDestroyWidget(USEPattFileWidget[NO_OF_PATTERN_SETS]); XtDestroyWidget(USETestPattFileWidget[NO_OF_PATTERN_SETS]); XtDestroyWidget(DELPattFileWidget[NO_OF_PATTERN_SETS]); USEPattFileWidget[NO_OF_PATTERN_SETS] = NULL; USETestPattFileWidget[NO_OF_PATTERN_SETS] = NULL; DELPattFileWidget[NO_OF_PATTERN_SETS] = NULL; } } /***************************************************************************** FUNCTION : ui_rem_updatePattList PURPOSE : Updates the lists of available pattern sets. Both the list under the DEL and the USE button are updated. RETURNS : void NOTES : Control panel has to be created before the call to this function UPDATE : 19.02.95 ******************************************************************************/ void ui_rem_updatePattList (void) { int i; int n = 1; Arg arg[10]; /* check whether any pattern files are loaded */ if(PATTERN_SET_FILE[CURR_PATTERN_SET] != NULL){ for(i=0; ilistType<7) listType = listDescriptorPtr->listType - 4; else listType = listDescriptorPtr->listType - 9; menu = XtCreatePopupShell("menu", simpleMenuWidgetClass, listDescriptorPtr->widgetPtr, NULL, 0); /* alloc space for function list */ ui_cb_list[listType] = (struct ui_cb_data *)calloc(krui_getNoOfFunctions(), sizeof(struct ui_cb_data)); /* create the list items */ i=0; func_name = ui_list_getFirstItem(listDescriptorPtr->listType); do{ mItem = XtCreateManagedWidget(func_name,smeBSBObjectClass, menu, NULL,0); ui_cb_list[listType][i].func_type = listDescriptorPtr->listType; ui_cb_list[listType][i].func_name = calloc(strlen(func_name)+1, sizeof(char)); strcpy(ui_cb_list[listType][i].func_name,func_name); XtAddCallback(mItem, XtNcallback, (XtCallbackProc) ui_rem_setFunc, (XtPointer) ((long)(listType*100 + i)));i++; func_name = ui_list_getNextItem(listDescriptorPtr->listType); }while (func_name != NULL); } /***************************************************************************** FUNCTION : ui_rem_setFunc PURPOSE : to set the Function selected by the mouse from the control panel RETURNS : NOTES : UPDATE : 05.04.95 ******************************************************************************/ void ui_rem_setFunc (Widget widget, int func_type, caddr_t call_data) { char buf[80]; int type,no,i; float dummy[UI_NO_REMAP_PARAMS]; krui_err error; for (i=0; i