javanns_kernelinterface.c

著名的神经网络工具箱

 */
JNIEXPORT jstring JNICALL
Java_javanns_KernelInterface_getFTypeOutFuncName(JNIEnv *jEnv, jobject jObj) {
  char *p = krui_getFTypeOutFuncName();
  if(p) return (*jEnv)->NewStringUTF(jEnv, p );
  else return (*jEnv)->NewStringUTF(jEnv, "" );
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setFTypeOutFunc
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setFTypeOutFunc(JNIEnv *jEnv, jobject jObj, jstring jName) {
  const char *name = (*jEnv)->GetStringUTFChars(jEnv, jName, 0);
  int i = krui_setFTypeOutFunc( (char *)name);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jName, name);
  isOK(jEnv, i);
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setFirstFTypeSite
 * Signature: ()Z
 */
JNIEXPORT jboolean JNICALL
Java_javanns_KernelInterface_setFirstFTypeSite(JNIEnv *jEnv, jobject jObj) {
  return krui_setFirstFTypeSite();
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setNextFTypeSite
 * Signature: ()Z
 */
JNIEXPORT jboolean JNICALL
Java_javanns_KernelInterface_setNextFTypeSite(JNIEnv *jEnv, jobject jObj) {
  return krui_setNextFTypeSite();
}

/*
 * Class:     javanns_KernelInterface
 * Method:    getFTypeSiteName
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL
Java_javanns_KernelInterface_getFTypeSiteName(JNIEnv *jEnv, jobject jObj) {
  char *p = krui_getFTypeSiteName();
  if(p) return (*jEnv)->NewStringUTF(jEnv, p );
  else return (*jEnv)->NewStringUTF(jEnv, "" );
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setFTypeSiteName
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setFTypeSiteName(JNIEnv *jEnv, jobject jObj, jstring jName) {
  const char *name = (*jEnv)->GetStringUTFChars(jEnv, jName, 0);
  int i = krui_setFTypeSiteName( (char *)name);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jName, name);
  isOK(jEnv, i);
}

/*
 * Class:     javanns_KernelInterface
 * Method:    createFTypeEntry
 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_createFTypeEntry(JNIEnv *jEnv, jobject jObj,
                                      jstring jFType,
                                      jstring jActFn,
                                      jstring jOutFn,
                                      jobjectArray jSiteNames) {
/*
  int i;
  const char *ftype = (*jEnv)->GetStringUTFChars(jEnv, jFType, 0);
  const char *actfn = (*jEnv)->GetStringUTFChars(jEnv, jActFn, 0);
  const char *outfn = (*jEnv)->GetStringUTFChars(jEnv, jOutFn, 0);
  jsize len = (*jEnv)->GetArrayLength(jEnv, jSiteNames);
  char **siteNames = (char **) malloc ( len * sizeof(char *) );
  if(!siteNames) {
    error(jEnv, "Malloc failed in createFTypeEntry");
    return;
  }
  jstring *p_jSiteNames = (*jEnv)->GetObjectArrayElements(jEnv, jSiteNames, 0);
  for(i=0; i<len; i++) {
    siteNames[i] = (*jEnv)->GetStringUTFChars(jEnv, p_jSiteNames[i], 0);
  }

  int i = krui_createFTypeEntry(ftype, actfn, outfn, len, siteNames);
  
  for(i=0; i<len; i++) {
    (*jEnv)->ReleaseStringUTFChars(jEnv, p_jSiteNames[i], siteNames[i]);
  }
  (*jEnv)->ReleaseObjectArrayElements(jEnv, jSiteNames, p_jSiteNames, 0);
  free(siteNames);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jOutFn, outfn);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jActFn, actfn);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFType, ftype);
  isOK(jEnv, i);
*/
}

/*
 * Class:     javanns_KernelInterface
 * Method:    deleteFTypeEntry
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_deleteFTypeEntry(JNIEnv *jEnv, jobject jObj, jstring jFType) {
  const char *ftype = (*jEnv)->GetStringUTFChars(jEnv, jFType, 0);
  krui_deleteFTypeEntry( (char *)ftype);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFType, ftype);
}

/*
 * Class:     javanns_KernelInterface
 * Method:    getNoOfFunctions
 * Signature: ()I
 */
JNIEXPORT jint JNICALL
Java_javanns_KernelInterface_getNoOfFunctions(JNIEnv *jEnv, jobject jObj) {
  return krui_getNoOfFunctions();
}

/*
 * Class:     javanns_KernelInterface
 * Method:    getFuncInfo
 * Signature: (I)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_getFuncInfo(JNIEnv *jEnv, jobject jObj, jint funcNo) {
  char name[128];
  char *p_name = name;
  int i;
  jclass cls = (*jEnv)->GetObjectClass(jEnv, jObj);
  jfieldID fid;

  krui_getFuncInfo( funcNo, &p_name, &i );

  fid = (*jEnv)->GetFieldID(jEnv, cls, "functionName", "Ljava/lang/String;");
  if(fid) (*jEnv)->SetObjectField(jEnv, jObj, fid, (*jEnv)->NewStringUTF(jEnv, name ) );
  fid = (*jEnv)->GetFieldID(jEnv, cls, "functionType", "I");
  if(fid) (*jEnv)->SetIntField(jEnv, jObj, fid, i);
}

/*
 * Class:     javanns_KernelInterface
 * Method:    isFunction
 * Signature: (Ljava/lang/String;I)Z
 */
JNIEXPORT jboolean JNICALL
Java_javanns_KernelInterface_isFunction(JNIEnv *jEnv, jobject jObj,
                                jstring jFnName,
                                jint fnType) {
  const char *fnName = (*jEnv)->GetStringUTFChars(jEnv, jFnName, 0);
  bool b = krui_isFunction( (char *)fnName, fnType);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFnName, fnName);
  return b;
}

/*
 * Class:     javanns_KernelInterface
 * Method:    getFuncParamInfo
 * Signature: (Ljava/lang/String;I)Z
 */
JNIEXPORT jboolean JNICALL
Java_javanns_KernelInterface_getFuncParamInfo(JNIEnv *jEnv, jobject jObj,
                                      jstring jFnName,
                                      jint fnType) {
  jclass cls = (*jEnv)->GetObjectClass(jEnv, jObj);
  jfieldID fid;
  int i, j;
  const char *fnName = (*jEnv)->GetStringUTFChars(jEnv, jFnName, 0);

  bool b = krui_getFuncParamInfo( (char *)fnName, fnType, &i, &j);

  (*jEnv)->ReleaseStringUTFChars(jEnv, jFnName, fnName);
  fid = (*jEnv)->GetFieldID(jEnv, cls, "function_inputs", "I");
  if(fid) (*jEnv)->SetIntField(jEnv, jObj, fid, i);
  fid = (*jEnv)->GetFieldID(jEnv, cls, "function_outputs", "I");
  if(fid) (*jEnv)->SetIntField(jEnv, jObj, fid, j);
  return b;
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setInitFunc
 * Signature: (Ljava/lang/String;[D)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setInitFunc(JNIEnv *jEnv, jobject jObj,
                                 jstring jFunction_name,
                                 jdoubleArray jParams) {
  jsize i;
  const char *function_name = (*jEnv)->GetStringUTFChars(jEnv, jFunction_name, 0);
  jsize len = (*jEnv)->GetArrayLength(jEnv, jParams);
  jdouble *params = (*jEnv)->GetDoubleArrayElements(jEnv, jParams, 0);

  isOK(jEnv, krui_setInitialisationFunc( (char *)function_name) );
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFunction_name, function_name);

  /* save values in corresponding global array */
  for(i=0; i<len; i++) init[i] = params[i];
  (*jEnv)->ReleaseDoubleArrayElements(jEnv, jParams, params, 0);

  for(; i<5; i++) init[i] = 0;
  initnum = 5;
  
  /* to enable to warn the user, set an init flag: */
  init_net_flag = TRUE;
}

/*
 * Class:     javanns_KernelInterface
 * Method:    getInitFunc
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL
Java_javanns_KernelInterface_getInitFunc(JNIEnv *jEnv, jobject jObj) {
  char *p = krui_getInitialisationFunc();
  if(p) return (*jEnv)->NewStringUTF(jEnv, p );
  else return (*jEnv)->NewStringUTF(jEnv, "" );
}

/*
 * Class:     javanns_KernelInterface
 * Method:    initNet
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_initNet(JNIEnv *jEnv, jobject jObj) {
  jclass cls = (*jEnv)->GetObjectClass(jEnv, jObj);
  jfieldID fid;

  /* initialize init parameter array:  */
  if (! init_net_flag) {
    for(i=0; i<NO_OF_INIT_PARAMS; i++) init[i] = 0.0;
    init_net_flag = TRUE;
  }

  isOK(jEnv, krui_initializeNet(init, initnum) );
  cyclenum = 0;
  fid = (*jEnv)->GetFieldID(jEnv, cls, "cycles", "I");
  if(fid) (*jEnv)->SetIntField(jEnv, jObj, fid, cyclenum);
}

/*
 * Class:     javanns_KernelInterface
 * Method:    updateSingleUnit
 * Signature: (I)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_updateSingleUnit(JNIEnv *jEnv, jobject jObj, jint unitNo) {
  isOK(jEnv, krui_updateSingleUnit(unitNo) );
}

/*
 * Class:     javanns_KernelInterface
 * Method:    getUpdateFunc
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL
Java_javanns_KernelInterface_getUpdateFunc(JNIEnv *jEnv, jobject jObj) {
  char *p = krui_getUpdateFunc();
  if(p) return (*jEnv)->NewStringUTF(jEnv, p );
  else return (*jEnv)->NewStringUTF(jEnv, "" );
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setUpdateFunc
 * Signature: (Ljava/lang/String;[D)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setUpdateFunc(JNIEnv *jEnv, jobject jObj,
                                   jstring jFunction_name,
                                   jdoubleArray jParams) {
  jsize i;
  const char *function_name = (*jEnv)->GetStringUTFChars(jEnv, jFunction_name, 0);
  jsize len = (*jEnv)->GetArrayLength(jEnv, jParams);
  jdouble *params = (*jEnv)->GetDoubleArrayElements(jEnv, jParams, 0);

  isOK(jEnv, krui_setUpdateFunc( (char *)function_name ) );
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFunction_name, function_name);

  /* save values in corresponding global array */
  for(i=0; i<len; i++) update[i] = params[i];
  (*jEnv)->ReleaseDoubleArrayElements(jEnv, jParams, params, 0);

  for(; i<5; i++) update[i] = 0;
  updatenum = 5;
  init_update_flag = TRUE;
}

/*
 * Class:     javanns_KernelInterface
 * Method:    updateNet
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_updateNet(JNIEnv *jEnv, jobject jObj) {

  /* initialize update parameter array:  */
  if (! init_update_flag) {
    for(i=0; i<NO_OF_UPDATE_PARAMS; i++) update[i] = 0.0;
    init_update_flag = TRUE;
  }

  isOK(jEnv, krui_updateNet(update, updatenum) );
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setLearnFunc
 * Signature: (Ljava/lang/String;[D)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setLearnFunc(JNIEnv *jEnv, jobject jObj,
                                  jstring jFunction_name,
                                  jdoubleArray jParams) {
  jsize i;
  const char *function_name = (*jEnv)->GetStringUTFChars(jEnv, jFunction_name, 0);
  jsize len = (*jEnv)->GetArrayLength(jEnv, jParams);
  jdouble *params = (*jEnv)->GetDoubleArrayElements(jEnv, jParams, 0);

  isOK(jEnv, krui_setLearnFunc( (char *)function_name) );
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFunction_name, function_name);

  /* save values in corresponding global array */
  for(i=0; i<len; i++) learn[i] = params[i];
  (*jEnv)->ReleaseDoubleArrayElements(jEnv, jParams, params, 0);

  for(; i<5; i++) learn[i] = 0;
  learnnum = 5;
  init_learn_flag = TRUE;
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setFFLearnFunc
 * Signature: (Ljava/lang/String;[D)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setFFLearnFunc(JNIEnv *jEnv, jobject jObj,
                                    jstring jFunction_name,
                                    jdoubleArray jParams) {
/* I.F.: do we need this method at all? */
  jsize i;
  const char *function_name = (*jEnv)->GetStringUTFChars(jEnv, jFunction_name, 0);
  jsize len = (*jEnv)->GetArrayLength(jEnv, jParams);
  jdouble *params = (*jEnv)->GetDoubleArrayElements(jEnv, jParams, 0);

  isOK(jEnv, krui_setFFLearnFunc( (char *)function_name) );
  (*jEnv)->ReleaseStringUTFChars(jEnv, jFunction_name, function_name);

  /* save values in corresponding global array */
  for(i=0; i<len; i++) ffLearn[i] = params[i];
  (*jEnv)->ReleaseDoubleArrayElements(jEnv, jParams, params, 0);

  for(; i<5; i++) ffLearn[i] = 0;
  ffLearnnum = 5;
  init_ffLearn_flag = TRUE;
}

/*
 * Class:     javanns_KernelInterface
 * Method:    setPruningFunc
 * Signature: (Ljava/lang/String;Ljava/lang/String;DDZIIDDZZ)V
 */
JNIEXPORT void JNICALL
Java_javanns_KernelInterface_setPruningFunc(JNIEnv *jEnv, jobject jObj,
                                    jstring jPrune_func,
                                    jstring jLearn_func,
                                    jdouble jPmax_error_incr,
                                    jdouble jPaccepted_error,
                                    jboolean jPrecreatef,
                                    jint jPfirst_train_cyc,
                                    jint jPretrain_cyc,
                                    jdouble jPmin_error_to_stop,
                                    jdouble jPinit_matrix_value,
                                    jboolean jPinput_pruningf,
                                    jboolean jPhidden_pruningf) {

  const char *prune_func = (*jEnv)->GetStringUTFChars(jEnv, jPrune_func, 0);
  const char *learn_func = (*jEnv)->GetStringUTFChars(jEnv, jLearn_func, 0);
  bool ok = TRUE;
  if(!isOK(jEnv, krui_setPrunFunc( (char *)prune_func) )) ok = FALSE;
  if(!isOK(jEnv, krui_setFFLearnFunc( (char *)learn_func) )) ok = FALSE;
  (*jEnv)->ReleaseStringUTFChars(jEnv, jPrune_func, prune_func);
  (*jEnv)->ReleaseStringUTFChars(jEnv, jLearn_func, learn_func);
  if(!ok) return;
  
  /* copy parameters to global values */
  max_error_incr = jPmax_error_incr;
  accepted_error = jPaccepted_error;
  recreatef = jPrecreatef;
  first_train_cyc = jPfirst_train_cyc;
  retrain_cyc = jPretrain_cyc;
  min_error_to_stop = jPmin_error_to_stop;
  init_matrix_value = jPinit_matrix_value;
  input_pruningf = jPinput_pruningf;
  hidden_pruningf = jPhidden_pruningf;
  
  pr_obs_setInitParameter(init_matrix_value);
  pr_setInputPruning(input_pruningf);
  pr_setHiddenPruning(hidden_pruningf);
}

/*