/// <summary>
/// Forward error calculation
/// </summary>
private void ForwardError(
double[] target,
int step)
{
Parallel.For(0, NodeLayer[2], new ParallelOptions {
MaxDegreeOfParallelism = Thread
},
z =>
{
Delta[2][z] = ErrorFunc.GetDeltaForwardError(
NodeStatus[step][2][z],
Net[step][2][z],
target[z],
ActivationFunc[1]);
});
//DEBUG
double errSum = 0.0;
for (int i = 0; i < NodeLayer[2]; i++)
{
double err = NodeStatus[step][2][i] - target[i];
errSum += err * err;
}
tot += errSum / NodeLayer[2];
}
public StateAPI(AppConfiguaraion appConfig, GameConfig gameConfig, ErrorFunc ef, InvokeFunction invokefunc)
{
this.appConfig = appConfig;
this.gameConfig = gameConfig;
errFunc = ef;
invokeFunction = invokefunc;
dropBoxFolderWatcher = null;
//currentPlayer = "";
}
public TcpSocketClient(string ip, int port)
{
this.ip = ip;
this.port = port;
_receiveBuffer = new byte[1024];
_state = State.DisConnect;
processBytesHandler = ProcessBytesHandler;
stateChanged = StateChangedHandler;
errorFunc = ErrorHandler;
}
/// <summary>
/// Forward error calculation
/// </summary>
private void ForwardError(double[] target)
{
Parallel.For(0, NodeLayer[Layer - 1], new ParallelOptions {
MaxDegreeOfParallelism = Thread
},
z =>
{
Delta[Layer - 1][z] = ErrorFunc.GetDeltaForwardError(
NodeStatus[Layer - 1][z],
Net[Layer - 1][z],
target[z],
ActivationFunc[Layer - 2]);
});
}
/// <summary>
/// 使用委托 封装try--catch---finally
/// </summary>
/// <param name="tryFunc"></param>
/// <param name="errorFunc"></param>
/// <param name="finallyFunc"></param>
public static void TryCatchFuc(TryFunc tryFunc, ErrorFunc errorFunc, FinallyFunc finallyFunc)
{
try
{
tryFunc.Invoke();
}
catch (Exception ex)
{
errorFunc?.Invoke(ex);
}
finally
{
finallyFunc();
}
}
public static void erf_values_test( )
//****************************************************************************80
//
// Purpose:
//
// ERF_VALUES_TEST tests ERF_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 February 2007
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("ERF_VALUES_TEST:");
Console.WriteLine(" ERF_VALUES stores values of");
Console.WriteLine(" the error function ERF(X).");
Console.WriteLine("");
Console.WriteLine(" X ERF(X)");
Console.WriteLine("");
int n_data = 0;
for ( ; ;)
{
ErrorFunc.erf_values(ref n_data, ref x, ref fx);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ fx.ToString(CultureInfo.InvariantCulture).PadLeft(12) + "");
}
}
public static void SetErrorCallback(ErrorFunc callback)
{
glfwSetErrorCallback(Marshal.GetFunctionPointerForDelegate(callback));
}
public static extern ErrorFunc SetErrorCallback(ErrorFunc callback);
public static void SetErrorCallback(ErrorFunc callback)
{
errorFunc = callback;
glfwSetErrorCallback(Marshal.GetFunctionPointerForDelegate(callback));
GC.KeepAlive(callback);
}
public static extern void ConnSetErrorFunc(IntPtr conn, IntPtr userData, [MarshalAs(UnmanagedType.FunctionPtr)] ErrorFunc handler);
public void SetErrorFunc(ErrorFunc func)
{
error_func_wrapper = new ErrorFuncWrapper (func);
IntPtr data = IntPtr.Zero;
if (func != null)
data = (IntPtr) GCHandle.Alloc (error_func_wrapper);
gp_glue_context_set_error_func (gluecontext, error_func_wrapper.NativeDelegate, data);
}
public ErrorFuncWrapper(ErrorFunc managed)
{
this.managed = managed;
if (managed != null)
NativeDelegate = NativeCallback;
}
/// <summary>
/// Evaluates a specified function based on the result state.
/// </summary>
/// <typeparam name="B">Result type.</typeparam>
/// <param name="success">Function to evaluate on <see cref="ResultState.Success"/> state.</param>
/// <param name="error">Function to evaluate on <see cref="ResultState.Error"/> state.</param>
/// <returns>Evaluated result.</returns>
public B Match <B>(
SuccessFunc <A, B> success,
ErrorFunc <Error, B> error)
=> ResultOperations.Match(this, success, error);
