/**
* http://en.wikipedia.org/wiki/Mandelbrot_set
* @param _Real x
* @param _Real y
* @param _Integer maximum iterations
* @return _Integer iterations until escape, 0 if it never escapes
*/
DLLEXPORT int mandelbrot(WolframLibraryData libData, mint Argc,
MArgument *Args, MArgument Res)
{
mreal re = MArgument_getReal(Args[0]);
mreal im = MArgument_getReal(Args[1]);
mint max_iters = MArgument_getInteger(Args[2]);
mreal Z_im = 0.;
mreal Z_re = 0.;
mreal Z_im2 = 0.;
mreal Z_re2 = 0.;
mint iter = 0;
for (; (iter < max_iters) && (Z_re2 + Z_im2 < 4); iter++) {
Z_im = 2. * Z_im * Z_re + im;
Z_re = Z_re2 - Z_im2 + re;
Z_im2 = Z_im * Z_im;
Z_re2 = Z_re * Z_re;
}
if (iter == max_iters)
iter = 0;
MArgument_setInteger(Res, iter);
return LIBRARY_NO_ERROR;
}
// Parameter order:
// inits
// params
// duration
EXTERN_C DLLEXPORT int runODE(WolframLibraryData libData, mint argc, MArgument *argv, MArgument aResult)
{
MTensor tensorInits = MArgument_getMTensor(argv[0]);
MTensor tensorParams = MArgument_getMTensor(argv[1]);
double duration = MArgument_getReal(argv[2]);
double dt = MArgument_getReal(argv[3]);
mint rankState = (mint)(sizeof(ODESTATE) / sizeof(double));
mint rankParams = (mint)(sizeof(ODEPARAMETERS) / sizeof(double));
// Trace("state:%d params:%d", rankState, rankParams);
ODESTATE inits;
ODEPARAMETERS parameters;
copyFromTensor(libData, (double*)&inits, rankState, tensorInits);
copyFromTensor(libData, (double*)¶meters, rankParams, tensorParams);
ODESTATE result = runODECore(inits, parameters, duration, dt);
MTensor tensorResult;
libData->MTensor_new(MType_Real, 1, &rankState, &tensorResult);
copyToTensor(libData, tensorResult, (double*)&result, rankState);
MArgument_setMTensor(aResult, tensorResult);
return LIBRARY_NO_ERROR;
}
DLLEXPORT int parabola(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res)
{
mreal x, a, f;
if (Argc != 2) return LIBRARY_FUNCTION_ERROR;
x = MArgument_getReal(Args[0]);
a = MArgument_getReal(Args[1]);
f = x*x - a;
MArgument_setReal(Res, f);
return 0;
}
/* Multiply two reals together, returning the result */
DLLEXPORT int demo1_R_R( WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
mreal R0;
mreal R1;
R0 = MArgument_getReal(Args[0]);
R1 = R0 * R0;
MArgument_setReal(Res, R1);
return LIBRARY_NO_ERROR;
}
/* Returns Sum[i*R0, {i, I0}] */
DLLEXPORT int Function01( WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
mreal R0;
mint I0;
mint i;
mreal R1;
I0 = MArgument_getInteger(Args[0]);
R0 = MArgument_getReal(Args[1]);
R1 = 0;
for ( i = 0; i < I0; i++) {
R1 = R1 + i*R0;
}
MArgument_setReal(Res, R1);
return LIBRARY_NO_ERROR;
}
DLLEXPORT int start_real_background_task(WolframLibraryData libData,
mint Argc, MArgument *Args, MArgument Res)
{
mint asyncObjID;
WolframIOLibrary_Functions ioLibrary = libData->ioLibraryFunctions;
RealBackgroundArgs threadArg = (RealBackgroundArgs)malloc(sizeof *threadArg);
if(Argc != 2)
return LIBRARY_FUNCTION_ERROR;
threadArg->ioLibrary = ioLibrary;
threadArg->pausemillis = MArgument_getInteger(Args[0]);
threadArg->eventdata = MArgument_getReal(Args[1]);
asyncObjID = ioLibrary->createAsynchronousTaskWithThread(RealBackgroundTask, threadArg);
MArgument_setInteger(Res, asyncObjID);
return LIBRARY_NO_ERROR;
}
/* Sets the I0,I1 th real element of T0 with value, returning that position */
DLLEXPORT int demo_TIIR_R(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0;
mint I0, I1;
mreal value, res;
mint dims[2];
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
I0 = MArgument_getInteger(Args[1]);
I1 = MArgument_getInteger(Args[2]);
value = MArgument_getReal(Args[3]);
dims[0] = I0;
dims[1] = I1;
err = libData->MTensor_setReal(T0, dims, value);
if (err) return err;
err = libData->MTensor_getReal(T0, dims, &res);
MArgument_setReal(Res, res);
return err;
}
EXTERN_C DLLEXPORT int InitSinkWriter(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {
// Get the arguments from MArgument
char *videofile = MArgument_getUTF8String(Args[0]);
// convert UTF8 filename to wide chars
int size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, NULL, 0);
WCHAR* videofileW = new WCHAR[size];
size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, videofileW, size);
// extract the sink parameters
mint encoder = MArgument_getInteger(Args[1]);
mint width = MArgument_getInteger(Args[2]);
mint height = MArgument_getInteger(Args[3]);
mreal framerate = MArgument_getReal(Args[4]);
mint kbps = MArgument_getInteger(Args[5]);
hr = VW.setParams(encoder, width, height, framerate, kbps);
if (FAILED(hr))
{
libData->Message("setsinkparamsfail");
return LIBRARY_FUNCTION_ERROR;
}
// Initialise the sink writer
hr = VW.initSinkWriter(videofileW);
// finished with the filename now
delete videofileW;
if (FAILED(hr))
{
libData->Message("initsinkfail");
return LIBRARY_FUNCTION_ERROR;
}
return LIBRARY_NO_ERROR;
}
DLLEXPORT int refine(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res)
{
int err;
mint i, j, k, m, n, nr;
mint const * dims;
mint rdims[2];
mreal dist, distsq;
mreal x1, x2, dx, y1, y2, dy, d, s, ds;
mreal *x, *y, *rx, *ry;
MTensor Targ, Tres;
dist = MArgument_getReal(Args[0]);
distsq = dist*dist*(1. + 1.e-8); /* Avoid adding extra points due to roundoff */
Targ = MArgument_getMTensor(Args[1]);
if (libData->MTensor_getType(Targ) != MType_Real) return LIBRARY_TYPE_ERROR;
if (libData->MTensor_getRank(Targ) != 2) return LIBRARY_RANK_ERROR;
dims = (libData->MTensor_getDimensions)(Targ);
if (dims[0] != 2) return LIBRARY_DIMENSION_ERROR;
n = dims[1];
x = libData->MTensor_getRealData(Targ);
y = x + n;
/* Do a pass to determine the length of the result */
x2 = x[0];
y2 = y[0];
nr = n;
for (i = 1; i < n; i++) {
x1 = x2;
y1 = y2;
x2 = x[i];
y2 = y[i];
dx = x2 - x1;
dy = y2 - y1;
d = dx*dx + dy*dy;
if (d > distsq) {
d = sqrt(d);
k = ((mint) ceil(d/dist)) - 1;
nr += k;
}
}
rdims[0] = 2;
rdims[1] = nr;
err = libData->MTensor_new(MType_Real, 2, rdims, &Tres);
if (err) return err;
rx = libData->MTensor_getRealData(Tres);
ry = rx + nr;
x2 = x[0];
y2 = y[0];
rx[0] = x2;
ry[0] = y2;
for (j = i = 1; i < n; i++, j++) {
x1 = x2;
y1 = y2;
x2 = x[i];
y2 = y[i];
dx = x2 - x1;
dy = y2 - y1;
d = dx*dx + dy*dy;
if (d > distsq) {
d = sqrt(d);
k = ((mint) ceil(d/dist)) - 1;
ds = 1./((mreal) (k + 1));
for (m = 1; m <= k; m++, j++) {
s = m*ds;
rx[j] = x1 + s*dx;
ry[j] = y1 + s*dy;
}
}
rx[j] = x2;
ry[j] = y2;
}
MArgument_setMTensor(Res, Tres);
return 0;
}
DLLEXPORT int duffing_crk4(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res)
{
int err = 0;
mint i, n, nh, rank;
mint const *dims;
mreal t0, t1, h;
mreal *x, *xr, *k, *k0, *k1, *k2, *k3;
MTensor Targ, Tres;
Targ = MArgument_getMTensor(Args[0]);
t0 = MArgument_getReal(Args[1]);
t1 = MArgument_getReal(Args[2]);
h = t1 - t0;
if (h < 0) return LIBRARY_FUNCTION_ERROR;
n = (libData->MTensor_getFlattenedLength)(Targ);
nh = n/2;
if (n != nh*2) return LIBRARY_DIMENSION_ERROR;
x = (libData->MTensor_getRealData)(Targ);
k = (mreal *) malloc(4*n*sizeof(mreal));
k0 = k; k1 = k0 + n; k2 = k1 + n; k3 = k2 + n;
for (i = 0; i < n; i++) k0[i] = x[i];
err = duffing_rhs(nh, t0, k0, k0 + nh);
for (i = 0; i < n; i++) {
k0[i] *= h;
k1[i] = x[i] + 0.5*k0[i];
}
err = duffing_rhs(nh, t0 + h/2, k1, k1 + nh);
if (err) goto clean_up;
for (i = 0; i < n; i++) {
k1[i] *= h;
k2[i] = x[i] + 0.5*k1[i];
}
err = duffing_rhs(nh, t0 + h/2, k2, k2 + nh);
if (err) goto clean_up;
for (i = 0; i < n; i++) {
k2[i] *= h;
k3[i] = x[i] + k2[i];
}
err = duffing_rhs(nh, t1, k3, k3 + nh);
if (err) goto clean_up;
rank = (libData->MTensor_getRank)(Targ);
dims = (libData->MTensor_getDimensions)(Targ);
err = (libData->MTensor_new)(MType_Real, rank, dims, &Tres);
if (err) goto clean_up;
xr =(libData->MTensor_getRealData)(Tres);
for (i = 0; i < n; i++)
xr[i] = x[i] + (k0[i] + 2.*(k1[i] + k2[i]) + h*k3[i])/6.;
MArgument_setMTensor(Res, Tres);
clean_up:
free(k);
return err;
}
