https://community.wolfram.com RSS Feed for Wolfram Community showing questions tagged with Tuning and Debugging with no replies sorted by active. https://community.wolfram.com/groups/-/m/t/3721357 In[83]:= LaunchKernels[] During evaluation of In[83]:= LinkObject::linkd: Unable to communicate with closed link LinkObject['/Applications/Wolfram.app/Contents/MacOS/WolframKernel' -noinit -subkernel -wstp,2002,23]. During evaluation of In[83]:= LinkObject::linkd: Unable to communicate with closed link LinkObject['/Applications/Wolfram.app/Contents/MacOS/WolframKernel' -noinit -subkernel -wstp,2003,24]. During evaluation of In[83]:= LinkObject::linkd: Unable to communicate with closed link LinkObject['/Applications/Wolfram.app/Contents/MacOS/WolframKernel' -noinit -subkernel -wstp,2004,25]. During evaluation of In[83]:= General::stop: Further output of LinkObject::linkd will be suppressed during this calculation. During evaluation of In[83]:= Parallel`Developer`ConnectKernel::failinit: 8 of 8 kernels failed to initialize. Out[83]= {} In[82]:= ParallelKernels[] Out[82]= {} In[80]:= AbsoluteTiming[ counts2X2X2sList = ParallelMap[ ArrayReshape[ (* Convert 1X8 counts into 2X2X2 counts; doing it this weird way - Flatten first - is much faster. *) Flatten@#, {Length@#, 2, 2, 2} ] &, counts1X8sList ] ][[1]] During evaluation of In[80]:= ParallelMap::nopar: No parallel kernels available; proceeding with sequential evaluation. Out[80]= 0.040537 Mark Tuttle 2026-05-24T12:29:20Z https://community.wolfram.com/groups/-/m/t/3635801 I have a few code samples which freeze or crash my kernel on evaluation, can anybody confirm that this isn't a local issue for me? Discrete: AudioGenerator[{"Color", AudioGenerator[TimeSeries[{1}, {1}]]}] Continuous: AudioGenerator[{"Color", AudioGenerator[{"Sawtooth", .4, 5}]}] Joseph Stocke 2026-02-06T21:20:51Z https://community.wolfram.com/groups/-/m/t/3562641 **The problem** I run Mathematica 12 from home via a Win11 VM on Proxmox. This configuration has run fine for years. Recently during an upgrade to Win11 25H2 I went to test to make sure everything was functional with a quick BenchmarkReport[] but it caused the kernel to die at Test 3, FFT. Its a very repeatable failure. Just before upgrading to 25H2 I had changed my processor type for this VM to x86-64-v3 +aes from -v2 + aes. I had issues on another vm where Win11 didnt want to upgrade with v2. I didnt originally run the processor as "host" as I am running dual E5-2699v4 Xeons, Win11 doesnt support by age despite having all the instructions needed. I have used this VM with Win10 and Win11 for years running Mathematica without issue. In the past I would use BenchmarkReport[] as a quick check of functionality after any upgrades or changes. This is the first time its failed. A quick test using ParallelTable[sin[x],{x,0,pi,10^-6}] works fine A quick test of Fourier[{1, 1, 2, 2, 1, 1, 0, 0}] works fine But a simple, Needs["Benchmark`"] BenchmarkReport[] Fails while calculating Step 3, FFT. The kernel simply die with no error message or warning. If I watch carefully with Task Manager it looks like the kernel dies, Mathematica recreates the kernel, then it dies again immediately. I also tried running this command through mathscript with -verbose but it gives me no additional details why its dying. I went back and tested some older notebooks I had. One of the first ones I tried died during a NonLinearModelFit of a PieceWise function with Sin[]s. Piecewise[{ { y0 + ( A1 Sin[ 2 \[Pi] ( x - x1)/t1] Sin[ 2 \[Pi] ( x - x2)/t2] ) + A3 Sin[2 \[Pi] (x - x3)/t3], x >= xon }, {y0, x < xon} }] This had worked in the past but now it dies just like BenchmarkReport, the kernel dies with no errors. **Fixes tried** So, I set the cpu back to v2 + aes for the vm config in proxmox but the kernel still dies. Set the cpu to Host in case its an issue with AES being passed correctly but it still dies I had Ballooning memory on so I turned it off, no change I had NUMA on so I turned it off, no change I uninstalled, reinstalled Mathematica 12.0 but it still fails I installed a demo copy of Mathematica 14.3, BenchmarkReport[] and my notebook run without issue. **System Info** Running a network version of Mathematica 12.0 with MathLM on another VM for the license. License is for 2 instances and 16 kernels. The VM is running under proxmox 8.4.14. The vm was just recently upgraded to Win11 25H2 but I am not sure when I last ran BenchmarkReport[]. I have run BenchmarkReport[] on this vm multiple times with some older flavors of win11 but I cant remember when I last ran it. I had recently installed the virtio drivers for this vm on the previous Win11 version but I hadnt run Mathematica since then. Could be a contributing factor. Proxmox has gone through a recent upgrade with a reboot of the host. I hadnt tried test Mathematica afterwards. Could be a contributing factor. The vm has been tested with cpu set to Host, x86-64-v2+aes, x86-64-v3+aes, numa on and off, ballooning on and off, with 32GB memory configured for the vm. This vm is set to get 2 processors of 8 cores each, The vm is only running microsoft virtual graphic drivers and is only accessed via remote desktop, not SPICE. As far as I can tell Win11 is working as expected. I am considering a fresh install of Win11 if no better ideas surface. The host system is dual E5-2699 v4 with 512GB. The host system runs a mix of vms and containers. **Summary** I know this is probably a very weird edge case of using a VM with such an old version of Mathematica. The kernel dying does seem to fail for more than just Benchmark so its most likely not a single package responsible. The failure is limited to Mathematica 12 as far as I can tell. Just wanted to figure this our before I start embarking on a bunch of calculations. Any thoughts are appreciated. Mike Morrell 2025-10-19T19:10:08Z https://community.wolfram.com/groups/-/m/t/3403358 I am working on a project that involves a high-dimensional matrix, pTA, of size 8*(p+2). I attempted to compute the sum of its negative eigenvalues using a supercomputer with 128 GB of RAM. For p=300, the computation took around 4 hours, and the memory usage reached 95%. However, I have realized that p=300 is insufficient for my research, and I need to set p=700. Given that the supercomputer struggled with p=300, I am certain it will not be able to handle p=700. I suspect that my Mathematica code is not optimized, which may be causing excessive memory usage and long computation times. Specifically, I believe that in my ParallelTable loop, Mathematica is computing all eigenvalues at each step, leading to inefficiencies. Can someone help me optimize my program to make it significantly faster and less memory-intensive, so it can handle larger values of p efficiently? &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/88e46108-9791-44ae-96d4-80ce3ea4746b Reza rho 2025-03-03T10:33:36Z https://community.wolfram.com/groups/-/m/t/3353494 I just began experimenting with running wolframsrcipt on Macos, so far the startup time is very disappointing. I wrote the following script: #!/usr/local/bin/wolframscript Print["hello"] Running this script takes roughly five seconds, consistently. For instance, here I time the script from bash: ~/bin # time ./hello.wls hello real 0m4.809s user 0m0.173s sys 0m0.049s Here is the version info for my installation of wolframscript: ~/bin # wolframscript -info Wolfram 14.1.0 Kernel for Mac OS X x86 (64-bit) Copyright 1988-2024 Wolfram Research, Inc. Is this typical performance? A five second startup for a trivial script is a deal breaker for me. If anyone can suggest ways to make this faster, or to diagnose the reasons for the slow startup I'd love to explore them. On the other hand, if this is the expected level of performance I'll explore other avenues for my scripting needs. Thank you. David Cabana David Cabana 2025-01-08T19:05:18Z https://community.wolfram.com/groups/-/m/t/3349604 Main goal of attached code is to expand expression *multipliedEq[N,h,t]* which is generated using parameters *N = wkbrzad* and *h = 2 ** *wkbrzad - 2* and subsequently collect expression by *t* in the most efficient way possible. Below, I include the part of my code which allows to generate the formula of *multipliedEq[N,h,t]*: dim = 6; j = 0; l = 1; f[r_] := 1 - r^(3 - dim); Q[r_] := ω^2 - f[r] * ((l * (l + dim - 3)) / r^2 + ((dim - 2) * (dim - 4)) / (4 * r^2) + ((1 - j^2) * (dim - 2)^2) / (4 * r^(dim - 1))); V[r_] = -Q[r]; QntaPochodna[r_, n_Integer] := QntaPochodna[r, n] = If[n == 0, Q[r], f[r] * D[Expand[QntaPochodna[r, n - 1]], r]]; pierwszapochodna[r_] = QntaPochodna[r, 1] // Expand; aa = Rationalize[Solve[pierwszapochodna[r] == 0, r, Reals] // N,0]; peak = Last[aa][[1]]; drugapochodna = (QntaPochodna[r, 2] // Simplify) /. peak; k = (1 / 2) * drugapochodna; s[n_, r_] :=(2 * QntaPochodna[r, n]) / (n! * drugapochodna) ss[n_, r_] := (1 / 4) * s[n, r] * (4 * k)^((2 - n) / 4) * Exp[n * I * Pi / 4] QQ[N_,t_]=\[Nu]+(1/2)-(1/4)*t^2+I*Sum[e^((2*n-1)/2)*ss[2*n+1,r]*t^(2*n+1)+e^n*(ss[2*n+2,r]*t^(2*n+2)-I*\[CapitalLambda][n+1]),{n,1,N-1}]; A[n_,t_]:=Sum[a[n,2*j]*t^(n+1-2*j),{j,0,Min[n, Floor[(n+1)/2]]}] g[h_,t_]:=t+Sum[e^(n/2)*A[n,t],{n,1,h}] \[Nu] = 1; lele[N_, h_, t_] = (Inactivate[(D[g[h, t], {t, 3}])]/(2*Inactivate[(D[g[h, t], t])]) - (3/4)*(Inactivate[D[g[h, t], {t, 2}]]/Inactivate[D[g[h, t], t]])^2 + ((1/2) + \[Nu] - ((Inactivate[g[h, t]])^2/4))*(Inactivate[D[g[h, t], t]])^2 - QQ[N, t]); multipliedEq[N_,h_,t_] = Map[ #*Inactivate[D[g[h, t], t]]^2 &, List @@ lele[N,h,t] ]; multipliedEq[N_,h_,t_] = Activate[multipliedEq[N,h,t]//Total]//Simplify; Next step is to generate a full equation for parameters *N* and *h* which are explicitly related to *wkbrzad* value: wkbrzad=6; maxOrder=2*wkbrzad - 2; multipliedEq2=multipliedEq[N, h, t]/. h -> 2*wkbrzad - 2 /. N -> wkbrzad /. peak /. \[CapitalLambda][c_] -> a[2*c - 2, 2*c]; And here goes my procedure which expands and collects the *multipliedEq[N,h,t]* by *t*: customProcess[equation_, e_, maxOrder_] := Module[{expandedEquation, truncatedEquation}, expandedEquation = Normal[Series[equation, {e, 0, maxOrder/2}]]; truncatedEquation = Collect[expandedEquation /. e^n_ /; n > maxOrder/2 :> 0, e]; truncatedEquation ]; praw1 = a_*e^_. -> a; ewspolczynniki = Collect[List @@ customProcess[multipliedEq2, e, maxOrder] /. praw1, t]; Unfortunately, the higher value of wkbrzad is (e.g. *wkbrzad = 100)*, the more time *customProcess* consumes to expand and collect. This is expected since a higher value of *wkbrzad* generates more terms to collect. However, there might be someone with a more sophisticated approach to handle such expansion and collection problems efficiently. I tried to apply idea from [here][1], but it was not fast enough: customProcess[equation_, e_, maxOrder_] := Module[{expandedEquation, truncatedEquation}, expandedEquation = ParallelMap[Series[#, {x, 0, maxOrder/2}] &, equation, Method -> "ItemsPerEvaluation" -> 15]; truncatedEquation = Collect[expandedEquation /. e^n_ /; n > maxOrder/2 :> 0, e]; truncatedEquation ]; [1]: https://mathematica.stackexchange.com/questions/177278/fast-expansion-of-large-expressions Maciej Kozyra 2025-01-02T15:31:33Z https://community.wolfram.com/groups/-/m/t/3311941 Thanks in advance for you interest, I'm seeking advice if there are ways to speed up the computation of my simulation, without reducing accuracy. I've been producing a simulation of an SDE of the Ornstein-Uhlenbeck process on a regular simplex. In particular, I look at a simplex with $m$ number of spatial dimensions, with the stochastic process $x$ starting at a uniform random location and evolving form there a tendency mean reversion. Further, the point of reversion changes halfway through the simulation. Because of the unusual domain the best way to get at this is through simulating many replicates and averaging them together (in fact, I'm interested in a function $R(x)$ of the process). However, I've had difficulty getting the standard error of the simulation low enough to for my purposes (finding min and max values over input parameter combinations). The levers I've been playing with are (1) number of replicates, (2) the time increment of simulation, (3) the SDE simulation method (e.g. Milstein). What I'm seeking is advice on is if there are ways I can change my code to induce quicker computation, without sacrificing accuracy (e.g., reducing number of replicates makes things quicker but less accurate). Thanks again for any input: (** Computes \[CapitalEpsilon][R(X)] **) (* \[Eta],\[Kappa],m,q,T are input parameters *) (* \[Eta]: upper limit of a simplex side *) (* \[Kappa]: rate of mean reversion *) (* m: number of spatial dimensions *) (* T: time limit *) (* \[CapitalDelta]t: the time increment of the SDE simulation *) (* reps: number of replicate simulations *) \[ScriptCapitalE]R[\[Eta]_, \[Kappa]_, m_, q_, T_, \[CapitalDelta]t_ : 0.01, reps_ : 10^4] := Block[{xopt0, xopt1, F, R, x0, xs, xts, B, M, \[Sigma], \[Mu], proc, RTs, t, \[Mu]0, \[Mu]1}, (** produces random initial condition for each replicate **) x0 = Map[\[Eta]*Join[#, {1 - Total[#]}] &, RandomVariate[DirichletDistribution[ConstantArray[1, {m}]], reps]]; (** produces label of each spatial variable: X_1,X_2,...,X_m *) xs = Table[Symbol["x" <> ToString[i]], {i, m}]; xts = Map[(#[t] &), xs]; (** produces the deterministic dynamics and noise correlation \ matrices **) (* mean reversion point is called xopt - there are two because dynamics change halfway *) xopt0 = ConstantArray[\[Eta]/m, {m}]; xopt1 = Clip[If[q < 1.00, Prepend[ConstantArray[\[Eta]/m - 1/m Log[(m - 1) q/(1 - q)], {m - 1}], \[Eta]/ m + (m - 1)/m Log[(m - 1) q/(1 - q)]], Prepend[ConstantArray[0, {m - 1}], \[Eta]]], {0, \[Eta]}]; (* matrices constrain movement to simplex domain *) B[x_] := DiagonalMatrix[Map[Boole[# > 0] &, x]]; M[x_] := Total[Map[Boole[# > 0] &, x]]; (* \[Sigma] is the correlation matrix, \[Mu] the deterministic \ transition matrix *) \[Sigma] = B[xts] . (IdentityMatrix[m] - 1/M[xts]*ConstantArray[1, {m, m}] . B[xts]); \[Mu][xoptin_] := \[Sigma] . (\[Kappa] (xoptin - xts)); (* two deterministic matrices because dynamics change halfway *) \[Mu]0 = \[Mu][xopt0]; \[Mu]1 = \[Mu][xopt1]; (* provides function which random vector process X from SDE is fed \ into *) F[x_] := 1 - E^-x; R[xvec_] := q*F[xvec[[1]]] + (1 - q)/(m - 1)*(Sum[F[xvec[[i]]], {i, 2, m}]); (** simulation of replicate trajectories **) (* halfway dynamics change *) (* 'proc' takes random initial condition and produces a trajectory *) (* trajectory is fed into 'R' *) proc[x0in_] := Block[{X0, X1}, X0 = RandomFunction[ ItoProcess[{\[Mu]0, \[Sigma]}, {xs, x0in}, {t, 0.}], {0., T/ 2, \[CapitalDelta]t}, Method -> "Milstein"]; X1 = RandomFunction[ ItoProcess[{\[Mu]1, \[Sigma]}, {xs, X0["LastValues"][[1]]}, {t, 0.}], {T/2, T, \[CapitalDelta]t}, Method -> "Milstein"]; TimeSeriesMap[R, TimeSeriesInsert[X0, X1]]["ValueList"] ]; (* replicates are paralellized over random initial condition values \ *)RTs = Parallelize@Table[proc[x0[[i]]], {i, reps}]; (* expected value over time and space is result *) Mean[Flatten[RTs]] ] (* on the order of 3 minutes *) AbsoluteTiming[\[ScriptCapitalE]R[1.00, .50, 3, 1.00, 1.00]] Cameron Turner 2024-10-30T17:42:19Z https://community.wolfram.com/groups/-/m/t/3292107 Hello. when I run the code below, i get the error NDSolveValue::reinitfail: Unable to reinitialize the system at t = 11.692137665979317` within specified tolerances. which i think is due to numerical instability in the calculations. any help on how to solve this issue would be greatly appreciated. ClearAll["Global`*"] m[n_] := Piecewise[{{0.1, n == 40}}, 0.0001]; l[n_] := 0.02; \[Zeta][t_] := 0.1 Cos[7 t] r[n_, t_] := \[Zeta][t] UnitVector[3, 3] + Sum[UnitVector[3, 1]*l[i] Sin[\[Theta][i, t]] - UnitVector[3, 3]*l[i] Cos[\[Theta][i, t]], {i, n}]; rdot[n_, t_] := D[r[n, t], t]; tt[nn_] := 1/2 Sum[m[n]*Total[rdot[n, t]^2], {n, nn}]; vv[nn_] := g*Sum[m[n]*r[n, t][[3]], {n, nn}]; ll[nn_] := tt[nn] - vv[nn]; rr[nn_] := 1/2 cd*Sum[Total[rdot[n, t]^2], {n, nn}]; eqLag[k_, nn_] := D[D[ll[nn], D[\[Theta][k, t], t]], t] - D[ll[nn], \[Theta][k, t]] == -D[rr[nn], D[\[Theta][k, t], t]]; Block[{nn = 40,(*m=Function[1],l=Function[1],\[Zeta]=Function[1],*) cd = 0.00005, g = 9.81}, eqs = Table[eqLag[n, nn], {n, nn}](*//Simplify*); initialData = Flatten[Table[{\[Theta][k, 0] == 0.05, Derivative[0, 1][\[Theta]][k, 0] == 0}, {k, nn}]]; sols = NDSolveValue[ Flatten@{eqs, initialData, WhenEvent[ 0.02 (Sin[\[Theta][1, t]] + Sin[\[Theta][2, t]] + Sin[\[Theta][3, t]] + Sin[\[Theta][4, t]] + Sin[\[Theta][5, t]] + Sin[\[Theta][6, t]] + Sin[\[Theta][7, t]] + Sin[\[Theta][8, t]] + Sin[\[Theta][9, t]] + Sin[\[Theta][10, t]] + Sin[\[Theta][11, t]] + Sin[\[Theta][12, t]] + Sin[\[Theta][13, t]] + Sin[\[Theta][14, t]] + Sin[\[Theta][15, t]] + Sin[\[Theta][16, t]] + Sin[\[Theta][17, t]] + Sin[\[Theta][18, t]] + Sin[\[Theta][19, t]] + Sin[\[Theta][20, t]] + Sin[\[Theta][21, t]] + Sin[\[Theta][22, t]] + Sin[\[Theta][23, t]] + Sin[\[Theta][24, t]] + Sin[\[Theta][25, t]] + Sin[\[Theta][26, t]] + Sin[\[Theta][27, t]] + Sin[\[Theta][28, t]] + Sin[\[Theta][29, t]] + Sin[\[Theta][30, t]] + Sin[\[Theta][31, t]] + Sin[\[Theta][32, t]] + Sin[\[Theta][33, t]] + Sin[\[Theta][34, t]] + Sin[\[Theta][35, t]] + Sin[\[Theta][36, t]] + Sin[\[Theta][37, t]] + Sin[\[Theta][38, t]] + Sin[\[Theta][39, t]] + Sin[\[Theta][40, t]]) <= 0, Derivative[0, 1][\[Theta]][40, t] -> -0.8* Derivative[0, 1][\[Theta]][40, t]]}, Table[\[Theta][k, t], {k, nn}], {t, 0, 20}, Method -> {"EquationSimplification" -> "Residual"}]] Ee Kin Chan 2024-10-07T02:06:00Z https://community.wolfram.com/groups/-/m/t/3282034 Hi, I'm trying to define a layer in a net with a given function that includes a matrix, "m", and its "Inverse [m]" but I get the error : "FunctionLayer::compiler: Cannot interpret Inverse[m] & as a network". &[Wolfram Notebook][1] Why am I getting this error? Thanks, Laura [1]: https://www.wolframcloud.com/obj/c7c79296-2a39-4c57-b255-79f19e16f381 Laura Pilozzi 2024-09-24T12:29:11Z https://community.wolfram.com/groups/-/m/t/3227384 A function is to be constructed that, given an input of a positive integer value m, automatically enumerates all possible cases. Starting with an arithmetic sequence of length 4*m + 2, two terms are removed leaving 4m terms, which are then evenly divided into m groups, each consisting of 4 numbers. It is required that the 4 numbers in each group form their own arithmetic sequence. The function should generate all combinations of the two removed terms and the corresponding m groups of four numbers forming arithmetic sequences. To clarify the problem statement further, let's break down the requirements: 1. An arithmetic sequence of length 4*m + 2 is created. 2. Two terms from this sequence are removed. 3. The remaining 4m terms are divided into m groups, each containing exactly 4 terms. 4. Each of these groups must also be an arithmetic sequence. 5. The function should output all possible combinations of the two removed terms and the resulting groups of four numbers that form arithmetic sequences. ![enter image description here][1] Finally, represent each outcome using the grid diagram shown above. f[m_] := Module[{S, graph}, S = Range[4 m + 2]; graph = RelationGraph[DisjointQ, Select[Subsets[S, {4}], Equal @@ Differences@# &]]; GroupBy[FindClique[graph, Length /@ FindClique[graph], All], Complement[S, Join @@ #] &]] grid[m_] := Grid[MapIndexed[{#2[[1]], Multicolumn[#, 2, Spacings -> 1]} &, Map[Function[x, TextGrid[ Range[4 m + 2] /. a -> Alternatives @@ Thread[a : Complement[Range[4 m + 2], Join @@ x] :> Highlighted[a, FrameMargins -> 0]], Frame -> All, FrameStyle -> Gray, Background -> {None, None, Join @@ MapIndexed[ Thread[Thread[{1, #}] -> Lighter[Hue[(Tr@#2 - 1)/Length@x], 0.85]] &, x]}]], Values@f[m], {2}]], Alignment -> Left, Spacings -> {Automatic, 1}] The above code is not producing results correctly. How can it be corrected or modified to achieve the correct output? [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=JpD9cdC2.jpg&userId=1828799 Lee Tao 2024-07-20T13:34:34Z https://community.wolfram.com/groups/-/m/t/3222475 Running official notebook from https://resources.wolframcloud.com/FunctionRepository/resources/SuiteSparseMatrix/ fails on `ssm = ResourceFunction["SuiteSparseMatrix"]["ash85"]` with the following error ![enter image description here][1] It appears trying to retrieve `ash85` gives an array of shape `(1, 0)` at some point. Can anyone see a simple fix so that I can run this locally? [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2024-07-16at1.12.50%E2%80%AFPM.png&userId=1046145 Yaroslav Bulatov 2024-07-16T20:13:38Z https://community.wolfram.com/groups/-/m/t/3222391 I want to get the bifurcation graphs of the two equations below, please guide me to code and modify &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/72cdf396-9334-42ca-ad98-2bd56d024356 Sajad Hoseini 2024-07-16T14:04:06Z https://community.wolfram.com/groups/-/m/t/3193984 How can i make this code faster &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/dde4985d-a668-498c-ad1a-eedd06612e73 Raghad Al-amri 2024-06-14T23:28:25Z https://community.wolfram.com/groups/-/m/t/3176227 Hi. Using a fresh kernel & fresh computer reboot on Version 14, I keep seeing odd behavior when attempting to load ExtensibleVector data structures that were exported in the MX format. Has anyone observed similar behavior? (screen shot below) ![enter image description here][1] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ExtemsibleVectorScreenshot.jpg&userId=99116 Todd Allen 2024-05-14T14:36:04Z https://community.wolfram.com/groups/-/m/t/3151464 Does anyone have a better solution for reading and writing half-precision float16? As far as I can find Mathematica does not support this at the moment or am I missing something? Currently, I'm reading the data as "UnsignedInteger16" and then converting it to binary and calculating the floating point number, but this feels a bit cumbersome. Int16ToFloat16 = Compile[{{int, _Integer, 0}}, Block[{bin, sign, imp, inf, exp, frac, signb, expb, fracb}, bin = IntegerDigits[int, 2, 16]; (*sign bit*) signb = bin[[1]]; (*exponent bits*) expb = bin[[2 ;; 6]]; (*fraction/significand bits *) fracb = bin[[7 ;; 16]]; (*check exponent*) imp = Max[expb]; inf = Min[expb]; (*Calculate sign exponent and signinficant*) sign = (-1.)^signb; exp = ({16, 8, 4, 2, 1} . expb) - 15.; frac = ({512, 256, 128, 64, 32, 16, 8, 4, 2, 1} . fracb)/1024; (*calculate the number*) If[imp === 0(*exp = 00000*), sign (2.^-14.) frac, If[inf === 1(*exp = 11111*), 0.(*make ininfity and NaN 0*), sign (2.^exp) (1 + frac)] ] ], RuntimeAttributes -> {Listable}, RuntimeOptions -> "Speed"]; the file can be found [here][1] list = BinaryReadList["positions.3.float16", "UnsignedInteger16"]; // AbsoluteTiming Dimensions@list Int16ToFloat16@list[[1 ;; 10000]]; // RepeatedTiming Int16ToFloat16[list]; // AbsoluteTiming The list contains around 40M numbers, reading the binary file takes less than a second but converting it to float more than 10. For storage, I'm just writing it as a float32 but this doubles the file size and the precision is not needed. [1]: https://drive.google.com/file/d/1C0p8CiIvVLpTkyIfyCMvbdFeI9IqqVMT/view?usp=drive_link Martijn Froeling 2024-04-02T07:46:14Z https://community.wolfram.com/groups/-/m/t/3060546 Hello, I am trying to tabulate solutions of some nonlinear algebraic equations, using FindRoot[], where the functions defining nonlinear equations are obtained by a numerical inversion of the Laplace transform. For the transform inversion I use the GWR function available from http://library.wolfram.com/infocenter/MathSource/4738/. The tabulation consist in a loop of (theoretically) independent solution acts for a number of different values of a parameter (called p in my program). It turns out that after every solution act there is an increase of the occupied memory space, which quickly leads to the memory overflow, despite the fact that I use Clear[] to release the most evident intermediate objects. I am unable to figure out the reason for this problem, among other things it is not clear to me whether the problem arises in the GWR code, or it has anything to do with FindRoot. I would appreciate any help. I am attaching a simplifed test code with a typical output showing that the amount of the apparent memory leak is ca. 2 MB in every solution act. Leslaw &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/242cf2c4-d832-4e67-bf42-7111d4f62c2f Leslaw Bieniasz 2023-11-04T22:59:28Z https://community.wolfram.com/groups/-/m/t/3025705 Using the following code to connect to the Arduino board, the following window will be shown, which requires the installation of the Arduino software. arduino = DeviceOpen["Arduino", "COM3"]; ![enter image description here][1] But because I have already installed the Arduino IDE software, I want to define its installation Path with the Device property "ArduinoInstallLocation" so I use the following code: arduino = DeviceOpen["Arduino", {"COM3","ArduinoInstallLocation" -> "C:\\Program Files\\Arduino IDE"}]; But it doesn't work for me. ![enter image description here][2] Please Help! I need to specify the installation path of Arduino Software. [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=1.png&userId=3025416 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2.png&userId=3025416 Harry Hunt 2023-10-02T16:41:50Z https://community.wolfram.com/groups/-/m/t/2940172 I think I may have stumbled across an issue with Mathematica’s built-in ConcaveHullMesh function that doesn’t seem to arise with Jon McLoone's NonConvexHullMesh resource function. The issue is illustrated in the attached notebook. My guess is that it occurs when the point values are modestly large (fairly typical of cartographical coordinate systems) and/or the number of points exceeds some threshold (noting that the function works when I take a small sample from the point dataset). From what I’m seeing, it looks like Jon's resource function may be more robust than the built-in function. Any thoughts or solutions other than what I've already tried would be welcomed. Many thanks, Ian &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/0941c754-35d6-4c37-b6de-464f0b97877d Ian Williams 2023-06-20T16:50:15Z https://community.wolfram.com/groups/-/m/t/2903058 Mathematica 13.2 is still not processor group aware, i.e. able to utilize multiple NUMA nodes on a single machine. More and more of today's CPU's are exceeding 32 physical cores (64 logical), not to mention dual CPU workstations that are quite common in high performance settings. Windows does not allow more than 64 logical processors in a single processor group, which means Mathematica cannot access the remaining processing power -- also apparent when you check $ProcessorCount. The current workaround is to disable hyperthreading/SMT which only raises the ceiling to 64 physical processors, but it is less than ideal and poor solution for dual CPU systems. Are there plans or methods to make Mathematica processor group aware? Not sure if there's any real technical difficulty in allowing different subkernels to be launched on different processor groups. I know that 3rd party tools such as Process Lasso can work but it would be better for Mathematica to have this ability natively. Sheldon Wu 2023-04-21T06:40:22Z https://community.wolfram.com/groups/-/m/t/2759635 Hi, I have a looped function, which includes a Map operation, that I've optimized for serial computation whose computation time grows roughly proportional to (N^2+N)/2, where N is the length of the loop. The bottle neck happens at the Map operation, so I do DistributeDefinitions[F, ..., from]; ParallelMap[F[...], from, Method->"CoarsestGrained"]; That works fine except every time I do a new ParallelMap the amount of memory the kernels are using grows until Mathematica crashes (and I have 64 GB of RAM...). Sadly, I find the documentation on parallel processing in Mathematica to be the poorest part of the documentation, mostly because the examples are far too simple (they are also all numeric - I'm doing symbolic computations) but also because there is no documentation on "Parallel`Developer`" nor the functions it contains, and no discussion on managing subkernel memory. At the beginning of my program I set HistoryLength = 0; and disable caching (which does not benefit what I'm doing - that's a different discussion). Those two things only effect the main kernel. So would "ParallelEvaluate[$HistoryLength = 0];" set the history length for the subkernels to 0 (if not we need an option somewhere to do it, assuming the subkernels have a history)? I know I could prevent this problem by quitting the subkernels and relaunching them, but that has a huge overhead cost (~ N AbsoluteTiming[LaunchKernels[]]) and would wipe-out any gains from parallel processing. I have tried "ClearKernels[]" but that doesn't fix the memory problem. So, should I change my code to ClearDistributedDefinitions[]; DistributeDefinitions[F, ..., from]; ParallelMap[F[...], from, Method->"CoarsestGrained"]; Is there anything else I should try? Troy Wahl 2023-01-04T19:04:55Z