https://community.wolfram.com RSS Feed for Wolfram Community showing ideas tagged with Mathematica with no replies sorted by most replies. https://community.wolfram.com/groups/-/m/t/3765991 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/7707125b-060b-4edc-8b98-f351f1362192 Alejandro Latorre Chirot 2026-07-21T20:35:05Z https://community.wolfram.com/groups/-/m/t/3766129 &[Wolfram Notebook][1] [ARCH]: https://www.wolframcloud.com/obj/d04b4a4b-4646-4f75-aac1-014cd19e6415 [1]: https://www.wolframcloud.com/obj/bfeb0b3a-cc12-418a-851e-2e8ea744585f Anton Antonov 2026-07-21T19:44:58Z https://community.wolfram.com/groups/-/m/t/3765436 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/e74ac1bf-671b-4a2c-843a-b1a318da3ff1 Alejandro Latorre Chirot 2026-07-20T17:49:55Z https://community.wolfram.com/groups/-/m/t/3765079 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/1abb4173-b7fc-4877-a55c-8323a10ec8e8 Alejandro Latorre Chirot 2026-07-19T20:49:18Z https://community.wolfram.com/groups/-/m/t/3761952 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/072025de-60dc-42cf-bb3c-927c443f3966 Alejandro Latorre Chirot 2026-07-16T15:26:50Z https://community.wolfram.com/groups/-/m/t/3761632 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/bf21afae-3930-4349-897a-6112b9c6b621 Alejandro Latorre Chirot 2026-07-16T13:49:34Z https://community.wolfram.com/groups/-/m/t/3747804 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/fce04a49-db2e-4247-97b3-fd987e17de28 AnneMarie Torresen 2026-07-07T16:32:14Z https://community.wolfram.com/groups/-/m/t/3735339 Kudos to WRI on release of Wolfram (Mathematica) Version 15. I jumped onto the new built-in AI Assistant [following along][1] Stephen's blog. In my trials, each trial a clean session (exit notebook and kernels), the example chat prompt "solve for the eigenmodes of a pentagonal drum" yielded varying results, not too surprising, but the second session produced failing code (syntax). Wanting to learn more, I browsed the Documentation Center ("Help"), searching on "AI Assistant" but the top hit, *tutorial/AIAssistant*, yielded a confusing page mixing the pre-V15 Notebook Assistant and V15 AI Assistant. There is better overview information available: [AI Assistant][3] and [AI Access][4]. Regarding the latter link, I wonder what is gained over the free (V15 included) "Basic" AI Access level by the paid "Pro" and "Research" levels. I'd very much appreciate an example chat session comparison between the three showing how the higher-level LLMs improve results over the Basic level. [1]: https://writings.stephenwolfram.com/2026/06/launching-version-15-of-wolfram-language-mathematica-built-in-useful-ai-lots-of-new-core-functionality/#an-ai-assistant-in-every-notebook "following" [2]: tutorial/AIAssistant [3]: https://www.wolfram.com/ai-assistant/ [4]: https://www.wolfram.com/ai-access/ Frank Iannarilli 2026-06-17T23:52:10Z https://community.wolfram.com/groups/-/m/t/3726656 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/4b2aea05-d260-4b29-804b-43bac36d7569 Daniel Carvalho 2026-06-03T15:23:31Z https://community.wolfram.com/groups/-/m/t/3576071 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/812246e9-fbb9-4bb2-843b-8a32ee650c55 Keisy Benavides Cruz 2025-11-17T00:23:29Z https://community.wolfram.com/groups/-/m/t/3569199 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/581e0b2c-c1c4-428b-b2d8-67501096ac1c Denis Ivanov 2025-11-02T07:36:59Z https://community.wolfram.com/groups/-/m/t/3563534 In this preliminary post I introduce the idea of dynamical Transformation Functions, that is, the situation where the Transformation Matrices have functions rather than numbers as entries. I apply this specifically in the case of even (direct) isometries of real 3-space. I introduce DITF format which is independent of the construction of the transformation function. I give a geometrical interpretation which shows motion in space not only the position but also the orientation of the object. Several examples are given. Barry H Dayton 2025-10-22T00:17:13Z https://community.wolfram.com/groups/-/m/t/3561390 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/9602e720-c5ee-4e57-bbde-c1b11e0b75d4 Daniel Carvalho 2025-10-16T23:00:15Z https://community.wolfram.com/groups/-/m/t/3489647 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/395cbe71-a81a-4bca-ac58-21cf61811605 Gilmer Gary 2025-07-01T15:36:59Z https://community.wolfram.com/groups/-/m/t/3401832 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/cf8cf2da-48f0-4028-9b71-e6436e901dae Housam Binous 2025-02-27T14:39:31Z https://community.wolfram.com/groups/-/m/t/3381079 ![Post-quantum hashing using chaotic double pendulum dynamics][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=5029proj-7-cover.jpeg&userId=20103 [2]: https://www.wolframcloud.com/obj/7279ca34-97b2-45f2-b1ee-581057e1f2a3 Wolfram Education Programs 2025-02-05T14:52:03Z https://community.wolfram.com/groups/-/m/t/3343692 This article primarily focuses on how to enhance the performance of highly intensive computational tasks through minor techniques, including functional programming, kernel parallelization, compilation optimization, and ultimately, utilizing the capability of GPU acceleration using CUDA. Linking Mathematica with C++ is also a great way to boost performance, but we will not cover it here, as Luyan Yu has authored another excellent article on this topic, available at: [Linking C++ code with Mathematica using LibraryLink - Luyan Yu](https://yuluyan.com/posts/mma-library-function/) Let’s begin with a simple task, find out the sum of all number digits within 1,000,000.: for example, sum of all number digits within 12 will be : 1+2+3+4+5+6+7+8+9+1+0+1+1+1+2=51. To solve the problem itself is fairly easy, we first consider number in this form from 000,000 to 999,999, each digit (0 through 9) appears an equal number of times in each position. For each position, the sum of every 10 digits is 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 = 45. Thus, The sum of the digits of all numbers in any given position is 45 * 100,000 = 4,500,000. Then, since there are six positions, the total sum of all digits from 000,000 to 999,999 is 6 * 4,500,000 = 27,000,000. Then we add 1,000,000 as a final 1 to get the result 27,000,001. The formula of total digits sum with in 10^x can be easily deduced, `x*45*10^(x-1)+1` or $$ f(x)=\frac{9}{2}\ 10^x x+1 $$ However, solving this specific problem is not our focus here, nor is the solving algorithm itself. This article aims to teach you techniques for enhancing the performance of any general function or algorithm you might write in the future. We will focus on optimizing performance by using different implementations of the same algorithm in Mathematica. Thus, the algorithm used for testing should be intentionally kept consistent for control variable purposes. Let's start with the simplest and most basic approach: C-style coding. We will use this as our baseline performance test algorithm. If you are a C programmer, you might write Mathematica code like this: ```mathematica cDigitSum[nn_] := Module[{sum = 0, n = nn}, While[ n > 0 , sum += Mod[n, 10]; n = Quotient[n, 10]; ]; sum ] AbsoluteTiming[ total = 0; For[n = 0, n <= 10^6, n++, total += cDigitSum[n] ]; total ] {11.9438, 27000001} ``` Costs around 12 seconds, which is not very efficient. but don’t be discoursed. Let’s see what Mathematica can do. Surprisingly, Mathematica has tons of magic built-in function, even include this one : `DigitSum`. Even more surprising is that it is slower than our humble and trivial `cDigitSum` function. ```mathematica AbsoluteTiming[ total = 0; For[n = 0, n <= 10^6, n++, total += DigitSum[n] ]; total ] {13.3594, 27000001} ``` It costs 13 seconds." Congratulations, you have beaten Mathematica in this case. We will no longer use Mathematica's built-in `DigitSum` function and will continue working based on our `cDigitSum` function." In Mathematica, using C-style coding is very inefficient. You can use a `Do` statement instead of `For` to make the code more elegant. ```mathematica AbsoluteTiming[ total = 0; Do[total += cDigitSum[n], {n, 10^6}]; total ] {10.9844, 27000001} ``` What can make code even more elegant by using `Map` operator form`/@`, and postfix form `//`. ```mathematica cDigitSum/@Range[10^6]//Total//AbsoluteTiming {10.7969, 27000001} ``` Functional programming usually makes code more elegant and easier to read and often provides better performance. However, since our performance here is limited by `cDigitSum`, it doesn’t boost the speed significantly. Nevertheless, Mathematica provides a way to boost functional-style code like `Do` or `Map` without modifying `cDigitSum` itself: kernel parallelization. Simply by applying the function `Parallelize` to the code, you can achieve a tremendous improvement in speed. `Warning:` Parallelization using `Do` involves setting up shared variables, which can cause a deadly performance drop due to rapid, concurrent writes to the same variable from all parallel kernels. Do not try this practice. However, I can demonstrate what happens if you do so. Please note that the quantity has been reduced to `10^4` to prevent the computation from hanging or crashing. ```mathematica (*DO NOT TRY THIS CODE*) AbsoluteTiming[ total = 0; SetSharedVariable[total]; Parallelize@Do[total += cDigitSum[n], {n, 10^4}]; total] (*DO NOT TRY THIS CODE*) {20.9006, 180001} ``` Here is the correct implement using a parallelized`Map` , as you can see there is a vast performance boost, we successfully achieved 2.2 seconds ```mathematica Parallelize[cDigitSum/@Range[10^6]]//Total//AbsoluteTiming {2.26036, 27000001} ``` Or even using a parallelized `Sum`: ```mathematica Parallelize@Sum[cDigitSum[n],{n,10^6}]//AbsoluteTiming {2.23265, 27000001} ``` We have achieved a amazing speed boost without change `cDigitSum` at all. The next technique is to tweak the implementation of function, without change the algorithm , what you can do is called `Compile` and `FunctionComile` . By using `Compile` we can write a compiled version of our `cDigitSum` : ```mathematica cDigitSumCompile = Compile[ {{nn, _Integer}} , Module[{sum = 0, digit, n = nn}, While[ n > 0 , digit = Mod[n, 10]; sum += digit; n = Quotient[n, 10]; ]; sum ] ] ``` By default, the `Compile` function will compile to `Wolfram Virtual Machine`, it is equivalent to ```mathematica cDigitSumCompileWVM = Compile[ {{nn, _Integer}} , Module[{sum = 0, digit, n = nn}, While[ n > 0 , digit = Mod[n, 10]; sum += digit; n = Quotient[n, 10]; ]; sum ] , CompilationTarget -> "WVM" ] ``` Let’s test it ```mathematica cDigitSumCompile/@Range[10^6]//Total//AbsoluteTiming {0.327939, 27000001} ``` ```mathematica cDigitSumCompileWVM/@Range[10^6]//Total//AbsoluteTiming {0.323876, 27000001} ``` Without using parallelization or modify the algorithm, we achieved 0.3 seconds ! From now, we will raise our n for this problem from `10^6` to `10^7` , let’s try it again: ```mathematica cDigitSumCompileWVM/@Range[10^7]//Total//AbsoluteTiming {3.68126, 315000001} ``` Instead of compile to `Wolfram Virtual Machine`, what you can do to achieve further improvement is compile to `C` ```mathematica cDigitSumCompileC = Compile[ {{nn, _Integer}} , Module[{sum = 0, digit, n = nn}, While[ n > 0 , digit = Mod[n, 10]; sum += digit; n = Quotient[n, 10]; ]; sum ] , CompilationTarget -> "C" ] ``` ```mathematica cDigitSumCompileC/@Range[10^7]//Total//AbsoluteTiming {2.36898, 315000001} ``` However, you can achieve more with compilation optimization options. Please note that in this specific case, since our test function is relatively simple, most optimization options would have little effect or meaningless. Nevertheless, I will enable all of them for demonstration purpose. ```mathematica cDigitSumCompileCOptimize = Compile[ {{nn, _Integer}} , Module[{sum = 0, digit, n = nn}, While[ n > 0 , digit = Mod[n, 10]; sum += digit; n = Quotient[n, 10]; ]; sum ] , CompilationTarget -> "C" , CompilationOptions -> {"ExpressionOptimization" -> True} , RuntimeAttributes -> {Listable} , RuntimeOptions -> "Speed" , Parallelization -> True ] ``` ```mathematica cDigitSumCompileCOptimize/@Range[10^7]//Total//AbsoluteTiming {2.03582, 315000001} ``` Another compile method is called `FunctionCompile` , ```mathematica cDigitSumFunctionCompile = FunctionCompile[ Function[Typed[nn, "MachineInteger"], Module[{sum = 0, digit, n = nn}, While[ n > 0 , digit = Mod[n, 10]; sum += digit; n = Quotient[n, 10]; ]; sum ] ] ] ``` We will not delve deeply into how to fine-tune `FunctionCompile` as it is currently in the experimental testing phase. However, its default settings generally perform quite well. ```mathematica cDigitSumFunctionCompile/@Range[10^7]//Total//AbsoluteTiming {0.538493, 315000001} ``` Once again, we achieved a speed of within 1 second. From now on, we will increase our test quantities from `10^7` to `10^8` and try it again.: ```mathematica cDigitSumFunctionCompile/@Range[10^8]//Total//AbsoluteTiming {5.41658, 3600000001} ``` We can certainly integrate the techniques of kernel parallelization with `Compile` or `FunctionCompile` to further enhance the speed. ```mathematica Parallelize[cDigitSumFunctionCompile/@Range[10^8]]//Total//AbsoluteTiming {2.22658, 3600000001} ``` What next? Can we further improve performance without altering the algorithm?" Yes, the answer is CUDA. First, you will need to load `CUDALink` package ```mathematica Needs["CUDALink`"] ``` Let’s write a CUDA function code `cudaDigitSumCode` first, this CUDA function takes a list of value as input, then for each element we apply our classic test algorithm to calculate the digit sum, then replace its original value. Notice here the `mint` data or `_Integer` in the specification of `CUDAFunctionLoad` is `Wolfram Language integer` ```mathematica cudaDigitSumCode = " __global__ void cudaDigitSum(mint *inout) { mint index = threadIdx.x + blockIdx.x * blockDim.x; mint n = inout[index]; mint sum = 0; while (n > 0) { sum += n % 10; n /= 10; } inout[index] = sum; } "; ``` we can then load this CUDA code by using `CUDAFunctionLoad` to get our `cudaDigitSum` function. ```mathematica cudaDigitSum = CUDAFunctionLoad[cudaDigitSumCode, "cudaDigitSum", {{_Integer}}, 1024] ``` Then we simply pass a list from 1 to 10^8 to this CUDA function ```mathematica cudaDigitSum[Range[10^8]]//First//Total//AbsoluteTiming {1.31861, 3600000001} ``` Can we go even faster? Yes, the data transfer time between the host (CPU) and the device (GPU) can be a significant bottleneck. Loading the data onto the GPU first using `CUDAMemoryLoad` can save considerable time during calculations. It's also crucial to remember to release the allocated GPU memory using `CUDAMemoryUnload` when it's no longer needed. CUDA functions operate directly on the memory space using pointers, which is why you need `CUDAMemoryGet` to retrieve the results. ```mathematica range=CUDAMemoryLoad[Range[10^8]]; AbsoluteTiming[cudaDigitSum[range];CUDAMemoryGet[range]//Total] CUDAMemoryUnload[range]; {1.06409, 3600000001} ``` Can we go even faster? Another speed optimization will be using the correct data type :**`unsigned int` (32-bit unsigned integer):** This type can hold values from 0 to 4,294,967,295. So, it can hold 3,600,000,001. we need to change the CUDA code slightly: ```mathematica cudaDigitSumUnsignedIntCode = " __global__ void cudaDigitSum(unsigned int *inout) { unsigned int index = threadIdx.x + blockIdx.x * blockDim.x; unsigned int n = inout[index]; unsigned int sum = 0; while (n > 0) { sum += n % 10; n /= 10; } inout[index] = sum; } "; ``` and recompile our CUDA function with the correct data specification: ```mathematica cudaDigitSumUnsignedInt = CUDAFunctionLoad[cudaDigitSumUnsignedIntCode, "cudaDigitSum", {{"UnsignedInteger32"}}, 1024] ``` Let’s retest the performance after optimized data type, remember to load the correct data type `UnsignedInteger32` in to memory: ```mathematica range=CUDAMemoryLoad[Range[10^8],"UnsignedInteger32"]; AbsoluteTiming[cudaDigitSumUnsignedInt[range];CUDAMemoryGet[range]//Total] CUDAMemoryUnload[range]; {0.785289, 3600000001} ``` Can we go even faster? Yes. You might notice that we keep using the `Total` function to calculate the total sum of the digit sums in the list. What if we perform this summation within CUDA as well? In other words, we pass a list of data to CUDA, and it returns the total sum directly. In this case, the computation is entirely offloaded to CUDA; Mathematica only serves to pass the raw data to CUDA and receive the computed result. We can write a new CUDA function called `cudaDigitSumsTotal`. ```mathematica cudaDigitSumsTotalCode = " __global__ void cudaDigitSum(unsigned int* in, unsigned int* out) { int index = threadIdx.x + blockIdx.x * blockDim.x; unsigned int n = in[index]; unsigned int sum = 0; while (n > 0) { sum += n % 10; n /= 10; } atomicAdd(out, sum); } "; ``` The `atomicAdd` function is used here to ensure the correctness of the variable during massive concurrent summation. You will almost certainly get incorrect results if you don't use it. Compile this to `cudaDigitSumsTotal`. ```mathematica cudaDigitSumsTotal = CUDAFunctionLoad[cudaDigitSumsTotalCode, "cudaDigitSum", {{"UnsignedInteger32", "Input"}, {"UnsignedInteger32", "Output"}}, 1024 ]; ``` Load the data into memory. ```mathematica in = CUDAMemoryLoad[Range[10^8], "UnsignedInteger32"]; out = CUDAMemoryLoad[{0}, "UnsignedInteger32"]; ``` And here are the results: ```mathematica AbsoluteTiming[ cudaDigitSumsTotal[in, out]; CUDAMemoryGet[out] ] {0.27297, {3600000001}} ``` Always remember to free memory. ```mathematica CUDAMemoryUnload[in]; CUDAMemoryUnload[out]; ``` 0.27297 seconds! for a quantity of `10^8`. Let's try a quantity of `10^9`, but we need to change our data type from `unsigned int`, as the result will overflow its range (0 to 4,294,967,295). `atomicAdd` only supports `unsigned int` and `unsigned long long`. With the extended range of `unsigned long long` (0 to 18,446,744,073,709,551,615), we should handle the sum correctly. ```mathematica `Needs["CUDALink`"] cudaDigitSumsTotalExtendCode = " __global__ void cudaDigitSum(unsigned int* in, unsigned long long * out) { int index = threadIdx.x + blockIdx.x * blockDim.x; unsigned int n = in[index]; unsigned long long sum = 0; while (n > 0) { sum += n % 10; n /= 10; } atomicAdd(out, sum); } "; cudaDigitSumsTotalExtend = CUDAFunctionLoad[cudaDigitSumsTotalExtendCode, "cudaDigitSum", {{"UnsignedInteger32", "Input"}, {"Integer64", "Output" }}, 1024]; in = CUDAMemoryLoad[Range[10^9], "UnsignedInteger32"]; out = CUDAMemoryLoad[{0}, "Integer64"]; AbsoluteTiming[ cudaDigitSumsTotalExtend[in, out]; CUDAMemoryGet[out] ] CUDAMemoryUnload[in]; CUDAMemoryUnload[out]; {2.73938, {40500000001}} ``` 2.7 seconds. This is where we end up. Let's do a quick review. Compared to the initial native approach, which took 12 seconds for `n = 10^6`, we've now reached 2.7 seconds for `n = 10^9`. That's more than 4,000 times faster, without changing the algorithm itself at all. In conclusion, we've journeyed from a straightforward but inefficient C-style solution to a highly optimized CUDA implementation, achieving a remarkable 4000x speedup. By maintaining a consistent digit-summing algorithm throughout, we've clearly demonstrated the profound impact of various optimization techniques. Functional programming, kernel parallelization, function compilation with optimization, and CUDA GPU acceleration, when strategically applied, can unlock the true potential of Mathematica for computationally intensive tasks. I hope this exploration has provided valuable insights and inspires you to optimize your own code. Thank you for joining me on this journey. eo iles 2024-12-24T10:26:02Z https://community.wolfram.com/groups/-/m/t/3258979 *This post links to an external web pages slide trail (which site necessarily also advertises Webel IT Australia's services). This forum post is for the interest of Mathematica users and the Wolfram Community, not for promotion of Webel IT Australia's services. Please restrict any discussions to Wolfram Language topics. Wolfram Community members may apply for access to a convenient self-contained PDF slide set version of the trail [here][1] (there's a form where you can provide a link to your Wolfram Community profile page).* --- Webel IT Australia is delighted to announce a new technical slide trail on the Webel libraries for Mathematica and the Wolfram Language, with **Systems Modeling Language v1 (SysML®)** models using the Webel **SysML4Mathematica (v1)** recipe: ['The Webel libraries for Wolfram Mathematica: With SysMLv1 models.'][2] *If you are not already familiar with it, OMG Systems Modeling Language (SysML) is the most used graphical language for Model-Based Systems Engineering (MBSE). There is now a SysMLv2 version that has its own textual representation code (a bit similar to Modelica code) - and Webel IT Australia is working on combining Mathematica with SysMLv2 - but only the SysMLv1.7 version is used in the linked slide trail.* This is a very detailed and technical slide trail (not a tutorial), one that will be maintained for many years to come. The underlying Wolfram Language code libraries can't currently be made available to the public (that may change), but you may still find the comprehensive examples in the slides of applications of the libraries and how SysML is used throughout interesting, and some of the related Policy Notes and coding conventions could be adopted easily without access to the full Webel libraries for the Wolfram Language. Some slides do include some code snippets. The trail is split into sections, some of which overlap, and some of which handle separate topics. If you wish to understand exactly what the slide trail is for and how it is organised it's best to read all of the intro page and the intro to each section, otherwise you may wonder what some Webel-specific notations and conventions mean and why some things are done as they are (and how some of them relate specifically to the SysML modelling recipe). If you are not interested in the SysML diagrams and are not familiar with SysMLv1 notations by all means do simply skip those slides. Many slides only have Mathematica application examples (some have SysML mini diagrams in them too). If you don't want to read each slide web page you can bring up a slide gallery viewer for each section in a desktop web browser and click through the slides (mileage with the slide viewer varies on iPhones and some mobiles). Since some sections handle some topics that may not be of interest to everyone, the following *Links Guide* (also [available as a page here][3]) may help you find what is of immediate interest to you. Over the next weeks many individual examples with detailed explanations may be posted on some LinkedIn Groups and this Wolfram Community forums. Until then, the following *Links Guide* may help you find your way through the slides and sections: --- **"I'm interested in the Webel SysML4Mathematica graphical modelling recipe and how it helps development of very complex Wolfram Language projects"** Visit: [SECTION: The Webel Mathematica libraries - INTRODUCTION - And the role of SysML][4] [SECTION: Modelling the Wolfram Language in SysMLv1 and related Webel coding conventions][5] If you skip these sections you'll see lots of examples in later slides anyway. --- **"I'm interested in the coding conventions for the Wolfram Language used by Webel"** If you skip these you may be left wondering about some of the notations used in later sections, but if you are keen to just get to application examples and case studies just skip them, you can always just use the many cross-linked Policy Note page or visit particular relevant later slides as needed: [SECTION: Webel coding and naming conventions for the Wolfram Language][6] [SECTION: The Webel \$opt\$ and \$arg\$ help holder conventions for options and arguments in the Wolfram Language][7] Note that some of these coding conventions are chosen to "play nicely" with the Wolfram Language Plugin for IntellijIDEA and with the SysML modelling (which was done in the MagicDraw/Cameo tool). --- **"I'm interested in the very low level Webel utility packages and the Webel help registry system."** [SECTION: A brief look at the Webel W\`Base\` utilities for Mathematica][8] [SECTION: The Webel Doc\` package and the HelpF\`, HelpO\` & HelpM\` help registry packages][9] The utilities section is not a high priority and the packages discussed have some basic low-level functions that would be obvious to most Mathematica users. The section on the Webel help registries for rich help for package functions and class "methods" (for MTools classes and Webel Abstract Data Type (ADT) *pseudo classes*) and `::usage` generation is far more likely to be of interest. --- **"I'm interested in the user-contributed MTools package for classes and object-orientation in the Wolfram Language and how it is extended by Webel classes. "** [SECTION: The Webel MAll & MOptsSet classes MTools extensions (with SysMLv1 models)][10] (It will help if you've viewed the section on the Webel help registries and at least had a glance at the section on the SysMLv1 modelling recipe above.) There's a nice example of use of a Webel **MAll** MTools class extension in this small physics case study trail section for the **MPsy** class: [SECTION: CASE STUDY: Applications of the Webel MTools class extensions to Psychrometrics (humid air physics). With SysMLv1 models.][11] *(Unfortunately at the time of writing some of the accompanying case studies for the Webel MTools extensions can't be made public, but there are some examples in other slide sections and trails elsewhere on the Webel site. The Webel MTools extensions have been applied with great effect to some very complex air conditioner and heat exchanger simulations and refrigerant circuit component modelling tasks, examples may become available later.)* --- **"I'm interested in the Webel recipe for Abstract Data Types (ADTs) as adapted from a technique for strong types originally by Roman Maeder and extended to include inheritance"** [SECTION: The Webel Abstract Data Type (ADT) stateless pseudo-classes with inheritance (with SysMLv1 models)][12] [SECTION: Webel ADT case study: Extracting structured data from unstructured Open XML spreadsheet data][13] Please note that: [Webel ADTs include inheritance (**and aren’t actually formal ADTs**)][14] --- **And a special request concerning any feedback on the trail** The Webel libraries for Mathematica make for - very special reasons such as Webel's projects combining Mathematica with SysML - heavy use of object-oriented and class-related coding strategies for the Wolfram Language, such as the Webel extensions to the user-contributed MTools for classes and OO in Mathematica, and the Webel Abstract Data Type (ADT) stateless *pseudo classes* with inheritance as described in detail in the linked slide trail. Feedback here on the linked trail with reference to specific slides by link is welcome (my time responding may be limited). Each slide page URL has a `/node/XXXX` identifier, you can just reference that node number `XXXX` if you don't wish to link to a slide page, or just reference the slide title. But I'd ask you to please not engage here in debates about the pros and cons of use of classes and OO with the Wolfram Language (and not "functional vs OO" debates). If you can work without such with more traditional use of the Wolfram Language and if that works for you for your own projects that's of course good; for the SysML-oriented Webel projects use of classes and some OO strategies is crucial and has proven extremely useful. Whether or not that's "the Mathematica way" is please *out-of-scope* for discussions regarding this Wolfram Community forum posting and the linked trail. I'm a huge fan of Mathematica and the Wolfram Language, and have decided to make it my primary development language and primary tool for data analysis and physics and engineering simulations (in combination with and in parallel with SysML for MBSE) for the rest of my professional life. I need classes and some aspects of OO for my particular SysML-oriented projects, and my focus is on finding ways of doing that effectively with the Wolfram Language. I am not trying to convince others of how they "should" use the Wolfram Language on their own projects. The Wolfram Language and Mathematica as a tool have some "short comings" (which they are depend on what you wish to achieve with them). I also have some "short comings" (quite a few actually), and my Wolfram Language code definitely has some "short comings". And I still have lots to learn about how to best use the Wolfram Language, Patterns, and its *super functional* capabilities effectively; sometimes what I initially thought were "short comings" were just my own ignorance about how to achieve things best with the Wolfram Language. Ultimately though, Mathematica is just so wonderful that its *pros* more than make up for any for perceived or real *cons*, and it's well worth finding ways of working with or around any limitations or challenges, which is part of what the linked trail is for. Finally, may I offer my eternal thanks to Mathematica expert [Faysal Aberkane][15] for kindly making his [MTools][16] packages for Object-Oriented Programming in Mathematica available to others. Without MTools, many of the applications by Webel IT of Mathematica and the Wolfram Language to some very demanding and complex projects and development of the **SysML4Mathematica** modelling recipe would not have been possible (or at least would have been far more difficult). I'd also like to thank Patrick Scheibe for his simply brilliant [Wolfram Language Plugin][17] for the IntelliJ IDEA. Haven't tried it yet? It's a "no brainer" for any really complex code-oriented Mathematica project. I hope you enjoy the linked technical slide trail and gain some benefit from your time spent examining any part of it. Dr Darren, Webel IT Australia, Aug 2024 [1]: https://www.webel.com.au/node/4177 [2]: https://www.webel.com.au/node/3918 [3]: https://www.webel.com.au/node/4179 [4]: https://www.webel.com.au/node/3920 [5]: https://www.webel.com.au/node/3921 [6]: https://www.webel.com.au/node/3922 [7]: https://www.webel.com.au/node/3991 [8]: https://www.webel.com.au/node/3923 [9]: https://www.webel.com.au/node/4021 [10]: https://www.webel.com.au/node/4067 [11]: https://www.webel.com.au/node/4178 [12]: https://www.webel.com.au/node/4093 [13]: https://www.webel.com.au/node/4129 [14]: https://www.webel.com.au/node/4110 [15]: https://community.wolfram.com/web/faysalaberkane [16]: https://community.wolfram.com/groups/-/m/t/880686 [17]: https://plugins.jetbrains.com/plugin/7232-wolfram-language Darren Kelly 2024-08-28T08:15:11Z https://community.wolfram.com/groups/-/m/t/3254456 **Wolfram Prerelease** is open to new beta testers! Your feedback will be very useful and will improve future releases of Wolfram products. If you're interested in participating in this program and receive the latest builds, please apply by sending an email to prerelease@wolfram.com with a self-intro and license number if you're an existing customer. Jay Yao 2024-08-23T19:30:12Z https://community.wolfram.com/groups/-/m/t/3152737 ![enter image description here][1] Contemporary ecological research requires robust analytical tools and techniques to model ecosystems reliably or study ecological data. Wolfram Language offers a broad and powerful toolkit for researchers exploring complex ecological questions. In this special online colloquium, we have invited research experts from around the world to share short presentations focused on their recent exciting work in ecology, highlighting how they have used Wolfram Language tools in their work. Learn about the wide-ranging applications of Wolfram Language for ecology, whether for data-driven discovery of spatial scales of habitat choice by elephants; assessing the effects of interplay between trophic structure, diversity and competition in a generalised consumer resource model; or modeling the effects of patch geometry on ecological release. Attendees will gain insights into the application of computational approaches to ecological studies, ranging from structural and spatial ecology to food web dynamical modeling, demonstrating the versatility and capability of Wolfram Language in addressing critical ecological challenges. To register for the event please follow the link below to the BigMarker platform. > [**Register here**][2] Please feel free to use this thread to collaborate and share ideas. Also, let us know what colloquium topics interest you for future events in this series! ![enter image description here][3] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=EcologyColloqImage.png&userId=2591433 [2]: https://www.wolfram.com/wolfram-u/courses/computational-thinking/ecological-research-with-wolfram-language/ [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=WolframUbanner.png&userId=2591433 Phileas Dazeley-Gaist 2024-04-04T15:48:58Z