/** * 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; }