https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Mathematica Add-Ons sorted by most likes. https://community.wolfram.com/groups/-/m/t/1931315 [![enter image description here][2]][1] &[Wolfram Notebook][3] [1]: https://youtu.be/rOa5IntICFA [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2020-04-09at12.54.33PM.png&userId=11733 [3]: https://www.wolframcloud.com/obj/afe2a2fb-ee55-4df5-a6fb-9bc16dd08af7 Brenton Bostick 2020-04-09T15:04:38Z https://community.wolfram.com/groups/-/m/t/560469 *WOLFRAM MATERIALS for the ARTICLE:* > Szabolcs Horvát, Jakub Podkalicki, Gábor Csárdi, Tamás Nepusz, Vincent Traag, Fabio Zanini, Daniel Noom, (2022). > *IGraph/M: graph theory and network analysis for Mathematica*. > arXiv:2209.09145 **[physics.soc-ph]**. > https://doi.org/10.48550/arXiv.2209.09145 [](https://igraph.discourse.group) [](https://github.com/szhorvat/IGraphM/releases) [](https://github.com/szhorvat/IGraphM#contributions) [](https://doi.org/10.5281/zenodo.1134932) ---- ##Article abstract IGraph/M is an efficient general purpose graph theory and network analysis package for Mathematica. IGraph/M serves as the Wolfram Language interfaces to the igraph C library, and also provides several unique pieces of functionality not yet present in igraph, but made possible by combining its capabilities with Mathematica's. The package is designed to support both graph theoretical research as well as the analysis of large-scale empirical networks. ---- ##Introduction The post below was written for the original release of IGraph/M. The package has come a long way since then and now contains ~300 functions. See http://szhorvat.net/mathematica/IGraphM for more details on the current release. Compatibility: 64-it Windows/macOS/Linux or Raspberry Pi; Mathematica <del>10.0</del> 11.0 or later. <a href="http://szhorvat.net/mathematica/IGraphM"><img src="https://community.wolfram.com//c/portal/getImageAttachment?filename=IGraphM-ad-3.png&userId=38370" width="300"></a> ---- I would like to announce IGraph/M, a new igraph interface for Mathematica: http://szhorvat.net/mathematica/IGraphM [igraph](http://igraph.org/) is a graph manipulation and analysis package. IGraph/M makes its functionality available from Mathematica. This initial release, version 0.1, covers only some igraph functions, as I focused on the things that I need personally. However the main framework is complete, and new functions can be added quickly. If anyone would like to contribute, please contact me. Binary packages for OS X (10.9 or later) and Linux can be downloaded [from GitHub](https://github.com/szhorvat/IGraphM/releases). Unfortunately, I was unable to compile the development version of igraph for Windows, so I cannot provide a Windows version. If you can help with compiling igraph itself (not IGraph/M) on Windows, please let me know! Functionality in this release that is not built into Mathematica: * Vertex betweenness centrality for weighted graphs * Estimates of vertex betweenness, edge betweenness and closeness centrality; for large graphs * Minimum feedback arc set for weighted and unweighted graphs * Find all cliques (not just maximal ones) * Count 3- and 4-motifs * Rewire edges, keeping either the density or the degree sequence * Alternative algorithms for isomorphism testing: Bliss, VF2 * Subgraph isomorphism * Test if a degree sequence is graphical * Alternative algorithms for generating random graphs with given degree sequence * Layout algorithms that take weights into account Note that IGraph/M is *not a replacement* for Mathematica's graphs and networks functionality. It is meant to complement what is already available in Mathematica, thus it primarily focuses on adding functionality that is not already present. Why did I release the package before covering most of the igraph functionality? I do not have time to work on things I do not personally need or use, so I am unlikely to extend it further unless the need comes up. I do think that the functions that are included in v0.1 can already be useful to others too. I would also like to give the opportunity for people to contribute to the project if they wish to. The groundwork has been laid, so further extensions should be quick and relatively easy. Also check out a related project, [IGraphR](https://github.com/szhorvat/IGraphR), which makes igraph available for Mathematica users through RLink. I wrote IGraph/M because I needed higher performance and greater reliability (especially for parallel computing) than what RLink could provide. ---- **A request:** If any of you have used IGraphR in the past to access igraph from Mathematica, please post a response to this thread and let me know which specific functions you were using. &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/94639221-60b4-47e3-8862-d996caa40388 Szabolcs Horvát 2015-09-06T12:55:14Z https://community.wolfram.com/groups/-/m/t/2445356 ![enter image description here][1] The popular game Wordle can take up a lot of your time. The author designed it so that it you can only play it once a day, thus saving us from ourselves :-). [Wordle][2] [NYTimes article on Wordle][3] But I couldn't resist the challenge to create a version of it in Mathematica, just for fun and because I was bored this past weekend. See the attached notebook and enjoy. Alas, since you can run it any number of times you are only to blame for yourself it you spend too much time on it. After executing the notebook just execute MWordle[Deploy] to bring up the game. A few additional comments. The notebook MWordle.nb has the option AutoGeneratedPackage -> Automatic which causes it, when saved, to create an MWordle.m package file in its same directory. The code in MWordle.nb is set up as a package with the context MWordle`Mwordle` If you want to set things up so that the package gets loaded and the MWordle game is automatically launched, do the following. Create a directory MWordleGame on your disk (The name MWordleGame can actually be whatever you wish.) And in the MWordleGame directory create a new directory called MWordle. (This name must be exactly that so that the MWordle`Mwordle` Context is property respected.) Put the MWordle.nb notebook in the MWordle dierectory, open it in Mathematica and save it so that the MWordle.m file is created in the MWordle directory. Then you can close the MWordle.nb notebook. Now in your MWordleGame directory save a new notebook -- you can call it whatever you wish, but something like LaunchMwordle.nb is a sensible choice. In that notebook create a button with the following command: CellPrint[TextCell[Button["Launch MWordle", Monitor[ If[! MemberQ[$Path, NotebookDirectory[]], AppendTo[$Path, NotebookDirectory[]]]; Needs["MWordle`MWordle`"]; MWordle`MWordle`MWordle[Deploy], Row[{ProgressIndicator[Appearance -> "Necklace", ImageSize -> Small], Spacer[5], Style["Launching MWordle...", 12, Blue, FontFamily -> "Arial"]}]], Method -> "Queued"], "Text", GeneratedCell -> False, CellAutoOverwrite -> False]] You now have a button in your LaunchMwordle.nb notebook which you can use any time you want to launch MWordle without having to execute the cells in the MWordle.nb notebook. Download the actual notebook from the link at the end of this post. The following is a version here to read. &[Wolfram Notebook][4] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Wordle.gif&userId=20103 [2]: https://www.powerlanguage.co.uk/wordle/ [3]: https://www.nytimes.com/2022/01/03/technology/wordle-word-game-creator.html [4]: https://www.wolframcloud.com/obj/08c015e2-0d65-4634-bf54-4b73e518f6d5 David Reiss 2022-01-13T21:47:44Z https://community.wolfram.com/groups/-/m/t/3043956 *Wolfram Language JavaScript Frontend:* *DOCUMENTATION:* https://jerryi.github.io/wljs-docs/ *GITHUB:* https://github.com/JerryI/wolfram-js-frontend ![enter image description here][1] **[Wolfram Language JavaScript Frontend](https://github.com/JerryI/wolfram-js-frontend)** is a project that aims to create a free, open-source alternative to Mathematica with its own features and benefits, and more specifically, to implement a user interface for the Wolfram Language (WL) kernel. You can use the kernel included in Mathematica or the Wolfram Engine. So this application is just a user interface for WL, not an attempt to completely rewrite the language. Below is a demonstration of the features, as well as the differences from Mathematica and other applications. You will definitely find this interesting if you like the programming approach that platforms like Mathematica, Jupyter, NTeract, JupyterLab, DeepNote, ObservableHQ, Google Collab, and a few others use. ## Installation The main system requirement is Wolfram Engine or Mathematica. Then you can go to the [release page](https://github.com/JerryI/wolfram-js-frontend/releases) and download an installer suitable for your system. Run the installer - first the application will be unpacked into the user directory, and then it will run. It is approximately the same as it happens with other applications on electron. Then you need to wait a bit until all dependencies are loaded and this window opens: ![enter image description here][2] ## Main menu It is intuitive and works about as a user would expect from most desktop applications. - *File* - allows you to create, open, save, export a notepad - *Edit* - cut, paste, delete, select - *Window* - reloads the window and controls the size - *Evaluation* - executes cell code, stops calculation and manages the kernel - *Misc* - customizations and information Especially worth noting is the *File > Share* item, which allows you to export Notepad to an HTML file, where all markup and interactive elements will be saved. Of course only those that do not require a connection to the core. To create a notepad with a demonstration of features, go to the *File > New* menu or press the **CTRL + N** key combination. After that, a new file with a random name and the extension .wln - Wolfram Language Notebook - will appear in the left navigation area. ## Navigation bar ![enter image description here][3] Navigation through files and directories is also very simple and intuitive. Directories can be opened. Files are opened on the main panel after clicking the left mouse button, and after clicking the right mouse button - a context menu appears, where the file can be opened in a separate window, renamed, copied, deleted, shown in the file manager. The navigator sidebar is minimized using the *"<<"* button. After moving to any directory, you can go back up a level by clicking on the top line in the navigator list with the name *"../"*. On the screenshot, our new file is already open on the main panel of the window. There is nothing in it yet, except for one empty cell with a small hint. ## Cells ![enter image description here][4] All notebooks contains list of cells and internal metadata. There is nothing else in them. There are different types of cells. First of all, they are divided into input cells and output cells. By default, the user can create only input cells using the keyboard and mouse. This is done either by clicking in the area between the cells in the document or by double-clicking the **↓** key in the last cell. Another way to create a new cell is by clicking on the **+** button that pops up when you hover over the area to the left of an existing cell. To delete, you must first delete all text and then press the **BACKSPACE** key. The result of executing your code appears in the cells with the output. What will be there depends on what the user entered. It can be a graph, text, markup and much more. To create such a cell, just press **SHIFT + ENTER** in any input cell (if there is a code there, of course). Then the application will read the code of the cell, send it to the interpreter, wait for the response and print the result below. For example, this is what the result will be when this code is executed: ```mathematica Graphics3D[Table[{RandomColor[], Sphere[RandomReal[1, 3], 0.05 + RandomReal[]/10]}, {25}]] ``` ![enter image description here][5] Notice the other popup buttons. In the lower left corner there is a down arrow that allows you to hide input, and in the upper right corner there are 4 more buttons in order: delete output, make initialization cell, detach result from window, and execute code (alternative to **SHIFT + ENTER**). If you execute the code again, the result will be replaced with a new one. In general, this is the main functionality of the application - interactive cells with code that immediately show the user the result. This is what we will focus on in more detail. ## Wolfram Language This is the main programming language supported here. After all, the entire backend is written in it. To write in this language, you don't need to do anything extra - just execute the code in the cell. For example, below is a demonstration of how to solve an equation: ```mathematica Solve[x^2 + 9 * x - 1 == 0, x] ``` ![enter image description here][6] In the animation above, you can see that the text output is printed formatted. The roots of the equation contain a radical sign, and rational numbers are displayed as fractions. It is worth mentioning here that all this is possible due to the use of [CodeMirror](https://codemirror.net) and [wljs-interpreter](https://github.com/JerryI/wljs-interpreter) JavaScript libraries. It is it that allows you to display formatted output so that under this output hides a completely different code without formatting - i.e. allow you to create syntactic sugar. And mathematical formulas are only a small and the most obvious part of this syntactic sugar. It is worth noting that the concept of displaying mathematical formulas here is most similar to Mathematica, but different from other tools with a "notebook" interface, such as [Jupyter](jupyter.org/), [DeepNote](https://deepnote.com/home), [Observablehq](observablehq.com), [nteract](https://nteract.io), and so on. All formulas are not just pretty markup, but are editable WL expressions that can be modified directly in the output cells. ![enter image description here][7] Not only formulas but any other objects are implemented using the same syntactic sugar and they too are supported by the editor: ![enter image description here][8] ## Markdown In addition to Wolfram Language support, the same input cells work with other programming languages and markup languages. In order to tell an application that a cell contains something that needs to be interpreted in a different way, it is necessary to enter a dot at the beginning of the cell, then the name of the language, and on the next line enter the code or markup itself. For example, for markdown it would look like this: .md # Demo notebook ## Markdown cells _you_ *can* __hide__ **the** input cell using the ~pop-up~ `buttons` on the [left side]() ## Supported languages * Wolfram * ect.. ## Wolfram code example (**)```wolfram Plot[Sin[x], {x, 1, 2}] (**)``` Then you just need to execute that cell and the output will show the formatted text: ![enter image description here][9] This way of typing can be thought of as if Notebook is a file editor and by specifying "extension" at the beginning we create an anonymous file whose text starts on the next line. We will come back to this comparison below, but for now let's move on to other supported languages. ## JavaScript This language is supported for obvious reasons - after all, the application is actually a web page packed in [electron](https://www.electronjs.org). As in the previous case, you just need to type "extension" in the first line, and then you can write code in JS. Below is an example of drawing circles on mouse click: ```javascript .js const canvas = document.createElement('canvas'); const context = canvas.getContext('2d'); canvas.width = 300; canvas.height = 400; let x, y const handleDrawCircle = (event) => { x = event.pageX; y = event.pageY; drawCircle(x, y); }; const drawCircle = (x, y) => { context.beginPath(); context.arc(x, y, 50, 0, 2 * Math.PI); context.strokeStyle = 'red'; context.stroke(); }; canvas.addEventListener('click', handleDrawCircle); return canvas; ``` Here's what it looks like in the notebook itself: ![enter image description here][10] Important features of JavaScript execution inside Notebook: - You must write return at the end of the cell to specify what to print in the output - All code is essentially wrapped in a function and has local scope only within a cell. That is, any declared functions and variables are only visible in a single cell - To create global functions and variables use the window object. JS gives full access to the entire document. With scripts in cells, you can change the entire interface beyond recognition. But you can also break it completely with the first script. ## HTML If markdown markup doesn't allow you to do what you want - you can use HTML in the cells. Everything works exactly the same by specifying .html in the first line. All markup from the input cell inserts into the output cell as a page fragment: ```html .html <button>click me!</button> <select> <option>WL</option> <option>JS</option> <option>MD</option> <option>HTML</option> </select> ``` ![enter image description here][11] HTML cells have one very important advantage. Code that is embedded in the markup is executed to the global scope. This can be useful for creating JavaScript functions available throughout the document. But even more useful is that you can import third-party scripts and styles from the HTML markup, as well as modify the styles of the current document. This is how, for example, I can add a rounded border to all code cells: ```html .html <style> .cm-editor { border-radius: 5px; } </style> ``` ![enter image description here][12] ## WolframScript Pages And the most important feature of HTML cells. They support WolramScript Pages (WSP) syntax by default. You can read more about the WSP technology itself on the [project page](https://github.com/JerryI/wl-wsp), but in short, it is an extension of XML syntax with a special tag `<?wsp code[] ?>`, which inserts a WL expression into the markup - i.e., it's about the same as it works in PHP. ![enter image description here][13] You can use almost any Wolfram language expression in WSP. You can insert functions defined inside Notebook, but most importantly, you can separate expressions with markup tags and then the text is mixed with code right inside the page. This is how, for example, you can create tables of several random shapes: ```mathematica randomFigure[] := Graphics[{{RandomColor[], RandomChoice[{Disk, Circle, Rectangle}][]}}, ImageSize -> 60 ] ``` .html <ul><?wsp Table[ ?><li><?wsp randomFigure[] ?></li><?wsp , {i, 1, 4}] ?></ul> ![enter image description here][14] ## Wolfram Language XML Extension Another technology that mixes WL code with page markup. Only now it looks like PHP, but like JSX. That is, it works the other way around - we write WL code and can add markup to it. You can read more about this technology on the documentation page, and to create a cell in the first line we write .wlx. Below is an example of a chart with a header and all this in one cell: ```mathematica .wlx Heading[Text_] := <h2 class="tracking-tight"><Text/></h2>; Graphics1 = Plot[Sin[x], {x, -4, 4}, ImageSize -> 350]; <body> <Heading> Hello World! </Heading> <Graphics1 /> </body> ``` ![enter image description here][15] Note the important features: - WL functions declared in the document are available inside WLX markup - Return the result enclosed in one common tag. - All HTML markup tags always start with a lowercase letter. - All tags that are converted into the result of WL execution are capitalized. - To insert a variable use `<Name />` - To insert a function:`<Func>arg1 arg2</Func>` - You can easily import scripts and styles ## Mermaid It's simple here. The Mermaid diagram support works on the basis of a JavaScript library. Here is for example a diagram that describes the backend of an application: ```mermaid .mermaid flowchart TD A[Frontend]-- HTTP+WS ---B(marster kernel) B---|WSTP+JTP|C[[sub kernel]] C-->|WS|A ``` ![enter image description here][16] ## Slides Another markup "language" that is supported using the RevalJS library. In the first line we specify the cell type .slide or .slides, and then we can use the RevalJS presentation rules. The simplest presentations are created using .md markup and using HTML. Here's an example: ```mathematica Graphics1 = Plot[Sin[x], {x, -2, 2}]; Graphics2 = Plot3D[Sin[x] + Cos[y], {x, -2, 2}, {y, -2, 2}]; ``` ```markdown .slide # Slide 1 2D graphics <Graphics1 /> --- # Slide 2 3D graphics <Graphics2 /> ``` ![enter image description here][17] Note that HTML in slide markup supports WLX by default, which means that while writing a presentation you can create various objects: graphs, pictures and charts in Wolfram and insert them directly into the presentation. Once a cell with the result is printed, it needs to be "detach" to switch to the slide show mode: ![enter image description here][18] ## ChatGPT We couldn't resist the temptation not to join the general wave of hype - so we added the ability to communicate with the GPT3.5 model directly from Notepad cells. To do this, just type .llm in the first line and any text on the next line: ![enter image description here][19] There are a couple of interesting features in cell-dialogs with a neural network: - The neural network's response is printed as a set of cell pairs: input + output - If the text is bad somewhere - you can easily edit the input and re-execute it - If the neural network responds with code in .md markup - it turns into input without output - All output is printed above the input cell, thus simulating the work of an assistant who fills in input cells with you from top to bottom and executes code in them. - When the first input cell is shifted to the very bottom - it becomes like a normal dialog or ChatGPT interface. ## Files At the very beginning of the review there was a comparison with anonymous files inside a cell. So cells can not only create "anonymous files in notepad", but also read existing files! To do this, you need to enter a file name in the first line and execute cell. For example, below we will export a picture and then print it in the next cell: ```mathematica Export["bubbleChart.png",BubbleChart[RandomReal[1, {5, 7, 3}]]] ``` ``` bubbleChart.png ``` ![enter image description here][20] You can also write text files like this: ``` file.txt col1, col2, col3 1, 2, 3 4, 5, 6 ``` Then read ``` file.txt ``` And then they will be available for import by Wolfram Language functions: ```mathematica Import["file.txt", "CSV", HeaderLines -> 1] ``` ![enter image description here][21] ## Conclusion and the headline image This concludes our review of the features of the free interface for Wolfram Language. This article did not cover all the features of the application, but only the most basic ones (not even all supported cell types). In addition to creating the interface itself, we (developers) also add our own useful features and plugins. Dear readers could see the result of such a function on headline image. In the picture, besides the logo and text, there is a real screenshot of a notepad with a 3D image of Spikey. So what's so special about this polyhedron? Well, the thing is that in the screenshot, this polyhedron is built using Graphics3D, but with ray tracing and HDRI lighting map (which has unavailable in Graphics3D inside Mathmetica). Here is the code that allows you to build a Graphics3D with Spikey and ray tracing: ```mathematica Graphics3D[{{Red, N@PolyhedronData["Spikey", "Polygons"]}}, Boxed->False,"RTX"->True,"Lighting"->None, ImageSize->{500, 400},"ViewProjection"->"Perspective", "Lightmap"->"https://raw.githubusercontent.com/JerryI/Mathematica-ThreeJS-graphics-engine/master/assets/PureSky.hdr" ] ``` ![enter image description here][22] That's definitely all for now! Thank you all for your attention and see you in the next articles and reviews! Our project is under active development and is constantly being updated. You can follow it on [GitHub](https://github.com/JerryI/wolfram-js-frontend) and on the [documentation page](https://jerryi.github.io/wljs-docs/). Freewawre Wolfram Language JavaScript Frontend developers Kirill Vasin (https://github.com/jerryi) and Kirill Belov (https://github.com/kirillbelovtest) were with you! [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=1.png&userId=937303 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2.png&userId=937303 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=3.png&userId=937303 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=4.png&userId=937303 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=5.png&userId=937303 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=6.gif&userId=937303 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=7.gif&userId=937303 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=8.gif&userId=937303 [9]: https://community.wolfram.com//c/portal/getImageAttachment?filename=9.png&userId=937303 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=10.png&userId=937303 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=11.png&userId=937303 [12]: https://community.wolfram.com//c/portal/getImageAttachment?filename=12.png&userId=937303 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=13.png&userId=937303 [14]: https://community.wolfram.com//c/portal/getImageAttachment?filename=14.png&userId=937303 [15]: https://community.wolfram.com//c/portal/getImageAttachment?filename=15.png&userId=937303 [16]: https://community.wolfram.com//c/portal/getImageAttachment?filename=16.png&userId=937303 [17]: https://community.wolfram.com//c/portal/getImageAttachment?filename=17.png&userId=937303 [18]: https://community.wolfram.com//c/portal/getImageAttachment?filename=18.gif&userId=937303 [19]: https://community.wolfram.com//c/portal/getImageAttachment?filename=19.gif&userId=937303 [20]: https://community.wolfram.com//c/portal/getImageAttachment?filename=20.png&userId=937303 [21]: https://community.wolfram.com//c/portal/getImageAttachment?filename=21.png&userId=937303 [22]: https://community.wolfram.com//c/portal/getImageAttachment?filename=22.png&userId=937303 Kirill Belov 2023-10-17T05:24:05Z https://community.wolfram.com/groups/-/m/t/1124967 > Website: https://visx.io/ > Announcement video: https://youtu.be/Ulz96RZXHAY > Beta version call: https://community.wolfram.com/groups/-/m/t/2713297 Hi everyone. I'm working on a visual interface to the Wolfram Language called [visX][1], and I'd like to ask what you all think of it. Wolfram Language code can often be thought of as a set of blocks, each of which takes some inputs, does something, and produces an output. VisX lets you write WL code exactly this way - you draw a digram, connecting blocks with links. For example, say you want to count how many times each digit (0 to 9) occurs in the first 30 digits of Pi. With text-based WL code, you'd write digits = RealDigits[N[Pi, 30]][[1]] Count[digits, #] & /@ Range[0, 9] In visX, you'd draw this: ![digits of Pi][2] I guess it's pretty self-explanatory. In addition to using built-in WL blocks, you can write your own, like the CountInList block. Normally, blocks just transform inputs to output, but the CountInList block is mapped over its input which is indicated by the little brackets on the outside of its connection ports. (That's basically visual syntactic sugar for "/@" or Map.) The 4 in the upper-right corner indicates that results inside this block are showing results from the 4-th time through the map. The block with "digits" in it sets a variable, which is then referenced in the CountInList block. You define blocks (which are basically functions) by just making an empty rectangle and dragging contents in then wiring them together, then you can use copies of the block wherever you want. A change in any copy of the block will be reflected in all other copies. There's no real difference between a defining a block and using it. Recursion can be specified by just including a copy of the block inside itself. Blocks can call other blocks in the same manner. Just like regular WL code, visX blocks can be nested deeply, but with the visual interface, it's easy to zoom in and out. At any point, the UI will show you the right amount of detail for each block - sometimes no detail at all, sometimes its name and labels on its inputs, sometimes its actual contents (which can then be edited or further zoomed...). visX is stand-alone software that runs locally on your machine, evaluates the diagram using your local Mathematica kernel, and receives the results and puts them back in the diagram. You can load data files using Import as usual. One of the problems that I've seen with visual languages in the past is that while simple things are easy to do, the code quickly gets too complex to manage and the visual interface starts to get in the way. With the Wolfram Language in theory everything is an expression, and this can lead you to write functional-style programs which are easily thought of as a diagram, but that's not always the most natural way to express a computation. Sometimes you just need a little for loop. Consider calculating Fibonacci numbers. Start the sequence with 1, 1, ... then each element of the sequence is the sum of the previous two. Yes, you can write a recursive algorithm to do this, but most people just want to write a little for loop. In visX, you can do this (calculates the 6th Fibonacci number): ![embedded code][4] I've tried to let you use blocks-and-links when that's the most natural thing (which is usually), and text-based code when that's better. Of course, you can mix them together however you want. A second problem I've found with visual programming languages is that it can actually be much slower to use then writing out text, because you have to laboriously drag and drop every single block. Even simple algebraic expressions like Sin[x]^2 + Cos[x]^2 2x^2 + 4x*y + 8y^2 would involve a lot of blocks because of all the Plus, Times, and Power blocks, as well as all the constants and symbols. With visX, you can enter Wolfram Language code snippets like those, and it will parse them and transform them into blocks which you can then insert into your diagram all at once and edit at will. This makes it much faster to get your idea onto the screen so that you can start evaluating it and developing it. I'm also working on the ability to take a visX block and give you back the Wolfram Language code that it represents. The examples given here are simple, but of course you can use this interface for putting together a complex piece of code as well. I find it especially handy when building up a calculation with lots of intermediate results along the way, or to rapidly prototype an algorithm where I want to be able to easily switch the data flows around. Does this project seem useful to anyone? I'd like to get some feedback - what do you think of it? Would you use it? For what? If there's interest, I could do a small-scale alpha test in about a month from now. More info at [visx.io][5]. -Nicholas Hoff *edited to clarify block definitions and recursion* [1]: http://visx.io [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=pi_digits_without_chrome.png&userId=1124239 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=pi_digits.png&userId=1124239 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=embeded_wl.png&userId=1124239 [5]: http://visx.io Nicholas Hoff 2017-06-20T10:02:52Z https://community.wolfram.com/groups/-/m/t/1788578 Today, we're happy to officially announce the first version of the [Wolfram Notebook Embedder][1] JavaScript library, which allows you to seamlessly embed [Wolfram Cloud](https://www.wolframcloud.com/) notebooks on websites. It can automatically resize a container based on the notebook size and it offers an API that can be used to "reach into" the notebook from the outer website, e.g. controlling a [Manipulate](https://reference.wolfram.com/language/ref/Manipulate.html) variable. These things were not easily possible by embedding notebooks using an `<iframe>`. ![HTML page with embedded JavaScript code that embeds a notebook into a given container div][2] You can read more on the [official Wolfram Notebook Embedder website](https://reference.wolfram.com/language/WolframNotebookEmbedder/), check out its [GitHub repository](https://github.com/WolframResearch/wolfram-notebook-embedder) or install the library from [npm](https://www.npmjs.com/package/wolfram-notebook-embedder). In addition to extensive [documentation](https://reference.wolfram.com/language/WolframNotebookEmbedder/docs/GettingStarted/), the website also contains a few interactive [examples](https://reference.wolfram.com/language/WolframNotebookEmbedder/examples/) for how to use the library. While we're really excited about this release, it still has some limitations to be aware of (see also the [troubleshooting guide](https://reference.wolfram.com/language/WolframNotebookEmbedder/docs/Troubleshooting/)): * Due to 3rd-party cookie blocking, embedded notebooks don't work very well in the Safari web browser right now. We don't track any personal data using these cookies, but we use them for load balancing, so we can't support certain features without these for now. Depending on the notebook content, you might still have to fall back to using an `<iframe>` in Safari. We're working on a solution to this (using a different load-balencing strategy). * Since the notebook is rendered directly into the DOM of the containing website, CSS definitions are shared between the two worlds and can "bleed" from the outside into the notebook and the other way around, potentially breaking styles in either of them. You might be able to work around such issues by increasing the [specificity](https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity) of your CSS definitions, so they (1) override conflicting definitions coming from the notebook and (2) do not affect the notebook. We're working on a more robust solution, perhaps using a separate [Shadow DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM) root for embedded notebooks to isolate all styling. If you encounter any other bugs, please [file an issue on GitHub](https://github.com/WolframResearch/wolfram-notebook-embedder/issues). This is just the beginning of our initiative to make notebooks easier to embed and interoperate with. Please let us know us what you want to do with this and if you have any questions, ideas or suggestions. One thing we're already starting to work on is an API (e.g. `https://www.wolframcloud.com/nb?url=...`) that will allow you to render a whole notebook (at a certain URL or with a certain content) on the fly – stay tuned. [1]: https://reference.wolfram.com/language/WolframNotebookEmbedder [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=hero.png&userId=29488 Jan Poeschko 2019-09-13T09:32:01Z https://community.wolfram.com/groups/-/m/t/3062832 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=w5qgsdf.jpg&userId=11733 [2]: https://www.wolframcloud.com/obj/04458d24-aacf-4cd7-8a5d-46efde37e927 Marco Thiel 2023-11-09T22:51:38Z https://community.wolfram.com/groups/-/m/t/963158 Recently John Fultz [announced][1] GitLink as open source on GitHub. He also mentioned the desire to offer more Wolfram related open source to the community. Draw was not mentioned by John but readers of his post followed the GitHub [link][2] and discovered the Draw repository. Naturally questions followed so here we are with an introduction of Draw, the latest open source contribution to the community. Draw is a vector drawing application. Many of the technical illustrations found in the Wolfram Language documentation were created using it. The release of Draw is to promote the advantages of using the Wolfram Language for software development. Draw was a personal project that grew from an idea to develop a simple tool to automate the drawing of flowcharts. This simple tool expanded in response to the need of functionality for solving specific challenges required by various illustrations. The Wolfram Language was very instrumental in helping Draw evolve during this process. Some of the more prominent features of Draw include: - Orthographic 3D drawing - Circuit, Mechanical and 3D library presets - Adjustable shapes such as gears or spirals - Shape arrays - Image autotrace The gallery of examples below demonstrate the capabilities of Draw: ![gallery][3] A look inside the application reveals an interface divided into four distinct sections: ![interface sections][4] An example of Draw being used to work on a flowchart: ![interface][5] The Circuit, Mechanical and 3D libraries: ![libraries][6] The adjustable gear shape: ![gear][7] The shape array: ![shape array][8] Hope this brief introduction is enough to inspire you to download the Draw notebook from [this GitHub link][9]. Start creating illustrations or explore the Wolfram Language code to discover how the application works. Support is available by clicking the blue help button for topics such as the basics, features, interaction, tools, examples and tips. Tooltips appear for all buttons detailing their behavior. Remember this is open source software and comes with no guarantee. That being said, feel free to kick the tires and take it for a spin. Draw works best when used in Mathematica 11 but most functionality is supported by Mathematica 10.4.1. [1]: http://community.wolfram.com/groups/-/m/t/960333 [2]: https://github.com/WolframResearch [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=examples.png&userId=28355 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=interfaceSections.png&userId=28355 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=interface.png&userId=28355 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=libraries.png&userId=28355 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=gear.png&userId=28355 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=shapearray.png&userId=28355 [9]: https://github.com/shdlbwr/draw Tim Shedelbower 2016-11-14T20:15:12Z https://community.wolfram.com/groups/-/m/t/3062403 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=fg45qw.jpg&userId=11733 [2]: https://www.wolframcloud.com/obj/34ac42c4-10de-4201-a158-6af47eda2bd8 Marco Thiel 2023-11-08T21:48:25Z https://community.wolfram.com/groups/-/m/t/2864162 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/04e935d4-d928-4868-adb8-ae6f84fae1f8 Anton Antonov 2023-04-02T19:01:27Z https://community.wolfram.com/groups/-/m/t/96823 Recently [b][url=http://community.wolfram.com/groups/-/m/t/91868]Christopher coded a neat wavelet-based method for peak detection[/url][/b]. Peak detection is often needed in various scientific fields: all sorts of spectral analysis, time series and general feature recognition in data come to mind right away.  There are many methods for peak detection. Besides his wavelet-based code Christopher also mentions a built-in MaxDetect function rooted in image processing. [b][url=http://reference.wolfram.com/mathematica/ref/MaxDetect.html]MaxDetect[/url][/b], though, being a rather elaborate tool for multi-dimensional data (2D, 3D images) and with a specific image-processing-minded parameter tuning, was not meant to target time series and other 1D data. This got me thinking. [b]Can we come up with a minimal compile-able peak detection code that would be accurate, robust and fast in most situations for 1D data?[/b] I am not an expert in the subject, but intuitively peak detection consists of two stages.  [list] [*][b]Finding all maxima[/b]. This can be done via Differences with selection of neighbor difference pairs that change from positive to negative. Such pair would indicate local maximum. [*][b]Filtering out peaks[/b]. Selecting those maxima that are “high” splashes of amplitude with respect to its “immediate neighborhood”. Quoted words are relative and depend on particular data. This is why they are set as tuning parameters in the algorithm. [/list]To illustrate 2nd point lets take a look at the [b][url=http://www.wolframalpha.com/input/?i=Albert+Einstein+Wikipedia+page+hits+history]Albert Einstein Wikipedia page hits history[/url][/b] below. Obviously a large peak in the past can be lower than current average in case if there is strong trend in the data. This is why we need “windowing” when looking for peaks, - to compare a peak to its immediate neighborhood.  [url=http://www.wolframalpha.com/input/?i=Albert+Einstein+Wikipedia+page+hits+history][img=width: 600px; height: 469px;]/c/portal/getImageAttachment?filename=ScreenShot2013-08-14at3.13.07PM.png&userId=11733[/img][/url] Without further ado here is a function written specifically in terms of functions that can be compiled. For example I do not use MovingAverage, but do trick with Partition instead.[mcode]PeakDetect = Compile[{{data, _Real, 1}, {width, _Integer}, {cut, _Real}}, (Table[0, {width}]~Join~ Map[UnitStep[# - cut] &, data[[1 + width ;; -1 - width]] - Map[Mean, Partition[data, 1 + 2 width, 1]]]~Join~ Table[0, {width}]) ({0}~Join~ Map[Piecewise[{{1, Sign[#] == {1, -1}}, {0, Sign[#] != {1, -1}}}] &, Partition[Differences[data], 2, 1]]~Join~{0}), CompilationTarget -> "C"];[/mcode]The legend for the function arguments is the following:[list] [*]data – 1D numerical list of data [*]width – half-width of the moving average window not including central point [*]cut – threshold at which to cut off the peak in natural units of data amplitudes  [/list]Now let’s see some usage cases. Let’s import the same Albert Einstein data as a proof of concept. [mcode]raw = WolframAlpha[ "albert einstein", {{"PopularityPod:WikipediaStatsData", 1}, "TimeSeriesData"}]; data = raw[[All, 2]][[All, 1]];[/mcode]We use total window width of 5 points here and cut off peak at a standard deviation of the whole data. The peak labeled “May 2008” is nicely picked up even though it is comparable then current average. This peak is most probably due to publication on May 13, 2008 of [b][url=http://www.amazon.com/Einstein-Life-Universe-Walter-Isaacson/dp/0743264746]one of the most famous books about Einstein[/url][/b] marked as New York Times bestseller that also got award Quill Award. Of course you can play with controls to pick or drop peaks. On the top plot one sees data, moving average, and bands formed by moving average displaced up and down by fraction of standard deviation. Any maximum above the top band becomes a peak. [url=http://www.amazon.com/Einstein-Life-Universe-Walter-Isaacson/dp/0743264746][img=width: 800px; height: 382px;]/c/portal/getImageAttachment?filename=9672ScreenShot2013-08-14at3.47.18PM.png&userId=11733[/img][/url] The code for the app is at the very end. Lets try a different data set – recent sun spot activity. [mcode]raw = WolframAlpha["sun spot", {{"SunspotsPartialTimeSeries:SpaceWeatherData", 1}, "TimeSeriesData"}]; data = raw[[All, 2]];[/mcode]We right away found on May 2013 mark - a [b][url=http://en.wikipedia.org/wiki/Solar_cycle_24#May_2013]most powerful recent event described in Wikipedia page here[/url][/b]. Please let me know if you have suggestions how to speed this up or improve it generally. I would be very curious to know your opinion and critique.  [color=#ff0000][i]The .GIF below is large - wait till it is loaded.[/i][/color] [img=width: 800px; height: 380px;]/c/portal/getImageAttachment?filename=sunspot.gif&userId=11733[/img] The following reference could be useful:[list] [*][b][url=http://www.tcs-trddc.com/trddc_website/pdf/SRL/Palshikar_SAPDTS_2009.pdf]Simple Algorithms for Peak Detection in Time-Series[/url][/b] [*][b][url=http://www.mdpi.com/1999-4893/5/4/588]An Efficient Algorithm for Automatic Peak Detection in Noisy Periodic and Quasi-Periodic Signals[/url][/b] [/list]The code for the interactive app:[mcode]Manipulate[ tt = {#, Rotate[DateString[#, {"MonthNameShort", " ", "Year"}], Pi/2]} & /@ Pick[raw, PeakDetect[data, wid, thr StandardDeviation[data]], 1][[ All, 1]]; Column[{ ListLinePlot[{data, ArrayPad[MovingAverage[data, 1 + 2 wid], wid, "Fixed"], ArrayPad[MovingAverage[data, 1 + 2 wid], wid, "Fixed"] + thr StandardDeviation[data], ArrayPad[MovingAverage[data, 1 + 2 wid], wid, "Fixed"] - thr StandardDeviation[data]}, AspectRatio -> 1/6, ImageSize -> 800, Filling -> {2 -> {1}, 3 -> {4}}, FrameTicks -> {None, Automatic}, FillingStyle -> {Directive[Red, Opacity[.7]], Directive[Blue, Opacity[.7]], Directive[Gray, Opacity[.1]]}, PlotStyle -> Opacity[.7], PlotRange -> All, Frame -> True, GridLines -> Automatic, PlotRangePadding -> 0], Show[ DateListPlot[raw, Joined -> True, AspectRatio -> 1/6, ImageSize -> 800, Filling -> Bottom, Ticks -> {tt, Automatic}, Frame -> False, Mesh -> All, PlotRange -> All], DateListPlot[ If[# == {}, raw[[1 ;; 2]], #, #] &[ Pick[raw, PeakDetect[data, wid, thr StandardDeviation[data]], 1]], AspectRatio -> 1/6, ImageSize -> 800, PlotStyle -> Directive[Red, PointSize[.007]], PlotRange -> All] , PlotRangePadding -> {0, Automatic}] }], Row[{ Control[{{thr, 1, "threshold"}, 0, 2, Appearance -> "Labeled"}], Spacer[100], Control[{{wid, 3, "hal-width"}, 1, 10, 1, Setter}] }] ][/mcode] [b]============== UPDATE =================[/b] Thank you all very much for contributing. I collected everyone's efforts and Danny's two functions in a single completely compile-able expression which seems to give shortest time; - but just vaguely faster then Danny's ingenious maneuver. I very much liked format suggested by Christopher, the one that Michael also kept in his packages. But I wanted to make some benchmarking and thus followed the format returned by the function [b][url=http://reference.wolfram.com/mathematica/ref/MaxDetect.html]MaxDetect[/url][/b] - simply for the sake of speed comparison. This format is just a binary list of the length of original data with 1s in positions of found peaks. Here is the function:[mcode]PeakDetect = Compile[{{data, _Real, 1}, {width, _Integer}, {cut, _Real}}, (Table[0, {width}]~Join~ UnitStep[ Take[data, {1 + width, -1 - width}] - (Module[{tot = Total[#1[[1 ;; #2 - 1]]], last = 0.}, Table[tot = tot + #1[[j + #2]] - last; last = #1[[j + 1]]; tot, {j, 0, Length[#1] - #2}]]/#2) &[data, 1 + 2 width] - cut] ~Join~Table[0, {width}]) ({0}~Join~ Table[If[Sign[{data[[ii + 1]] - data[[ii]], data[[ii + 2]] - data[[ii + 1]]}] == {1, -1}, 1, 0], {ii, 1, Length[data] - 2}]~Join~{0}), CompilationTarget -> "C"]; dat = RandomReal[1, 10^7]; pks = MaxDetect[dat]; // AbsoluteTiming Total[pks] (* ======== output ======== {62.807928, Null} 3333361 ======== output ======== *) pks = PeakDetect[dat, 1, 0]; // AbsoluteTiming Total[pks] (* ======== output ======== {1.560074, Null} 3333360 ======== output ======== *)[/mcode]And here are the speed benchmarks on 10 million data points which shows 40 times speed-up: Vitaliy Kaurov 2013-08-14T21:21:54Z https://community.wolfram.com/groups/-/m/t/787142 ## General information and download links ## If you're interested in crystal structures, you can now download the Crystallica application from the Wolfram Library Archive, and then you can do things like this: Needs["Crystallica`"]; CrystalPlot[ {{5.4,0,0},{0,5.4,0},{0,0,5.4}}, {{0,0,0},{0,0,.5},{0,.5,0},{.5,0,0},{.24,.24,.24},{.24,.76,.76},{.76,.24,.76},{.76,.76,.24}}, {1,2,2,2,3,3,3,3}, AtomCol->{"Firebrick","YellowGreen",White},AtomRad->.4, BondStyle->2,BondDist->3, CellLineStyle->False,AddQ->True,Lighting->{{"Directional",White,ImageScaled[{0,0,1}]}},Background->Black] ![enter image description here][1] Here are the download links for Crystallica and two other packages you may need: [Crystallica][2] - contains the functions `CrystalPlot` and `CrystalChange` [CifImport][3] - contains an import function for CIF files [VaspImport][4] - contains an import function for files related to [VASP][5] Once you've installed Crystallica (by saving the entire Crystallica folder - not the zip archive - to `$USerBaseDirectory/Applications` and re-starting the Kernel), you can enter Crystallica into the Documentation Center and you'll find lots of useful examples. Most of the examples in this post are taken from the Documentation. For the other two packages, just install them and evaluate this: ?CifImport ?VaspImport I'll first show you a few things the `CrystalPlot` function can do when you already have crystal structure data inside Mathematica, wherever it may have come from. Then we'll take a look at how to get the data into Mathematica in the first place, which is where `CifImport` and `VaspImport` will come into play - but we'll get data from other sources as well. I'll cover the different import solutions in separate replies to this thread, because I have a feeling that I'll be rambling on and on and on... ## Simple plot ## Traditional ball-and-stick plots are usually just fine, so the simplest thing you can do is this: CrystalPlot[ {{4.5,0,0},{0,4.5,0},{0,0,3}}, {{0,0,0},{.5,.5,.5},{.2,.8,.5},{.3,.3,0},{.7,.7,0},{.8,.2,.5}}, {1,1,2,2,2,2}] ![enter image description here][6] As you can see, `CrystalPlot` expects three arguments. The first one contains the lattice vectors, which are simply the three vectors that create the parallelepiped that constitutes the cell. The second argument contains the atomic coordinates, but they're given in the basis of the lattice vectors (which is quite useful in crystallography). The third argument is a list of integers that gives the atom types, with one entry for each atom. If you want to plot a molecule instead, you can call `CrystalPlot` with just two arguments: A list of atom coordinates in cartesian space, and a list of atom types. Everything else you see in the plot - the atoms, bonds, colours, arrows etc. - represents the default settings of various layout options. ## Advanced atoms and bonds ## Let's take a look at some more advanced options just for fun. For instance, atoms and bonds can look any way you need them to, because you can specify your own functions for them. You can also fine-tune where to put bonds and what to do with their thickness and colour in a physically (or chemically) meaningful way, but I won't show that here. So here are some customized atoms and bonds: Row[Table[ CrystalPlot[{{4,0,0},{0,4,0},{0,0,4}},{{0,0,0},{.4,.4,.4},{.8,.8,.8}},{1,2,3}, AtomRad->{.4,1.2,.7},AtomFunction->style,ImageSize->400], {style,{ (Ball[#1,#2]&), (Scale[Sphere[#1,#2],{1,1,.5}]&), ({EdgeForm[Thick],Opacity[.7],Cuboid[#1-.5*#2,#1+.5*#2]}&) }}]] ![enter image description here][7] Row[Table[ CrystalPlot[{{0,0,0},{5,0,0},{2.5,4,0}},{1,2,3},BondDist->6,BondStyle->style,ImageSize->400], {style,{ 1, Function[{bonds,partcol},Table[{If[ii<.5,partcol[#,1],partcol[#,2]],Sphere[bonds[[#,1]]+ii*(bonds[[#,2]]-bonds[[#,1]]),.15]},{ii,0,1,1/9}]&/@Range[Length[bonds]]], Function[{bonds,partcol},Module[{spiral,points,rad=.05}, spiral[atoms_]:=Module[{scale=.5,dist=atoms[[2]]-atoms[[1]],curls=60,normal,rot,scaled}, normal=Table[{scale*Cos[ii],scale*Sin[ii],.1*ii},{ii,0,curls,\[Pi]/10}]; scaled={#[[1]],#[[2]],10*Norm[dist]/curls*#[[3]]}&/@normal; rot=scaled.Quiet[RotationMatrix[{dist,{0,0,1}}]]; Join[{atoms[[1]]},#+atoms[[1]]&/@(rot[[25;;-25]]),{atoms[[2]]}]]; points=spiral/@bonds; {partcol[#,1],Tube[BSplineCurve[points[[#,;;Round[Length[points[[#]]]/2]]],rad]],partcol[#,2],Tube[BSplineCurve[points[[#,Round[Length[points[[#]]]/2];;]],rad]]}&/@Range[Length[bonds]] ]] }}]] ![enter image description here][8] ## Lattice planes ## Crystallica can also add lattice planes to the plot. You can specify them using [h,k,l] Miller indices and distance to the origin. CrystalPlot[{{3,0,0},{0,3,0},{0,0,3}},{{0,0,0}},{1}, AddQ->True,AtomRad->.3,AtomCol->"CadmiumYellow",Sysdim->2,CellLineStyle->2, LatticePlanes->Table[{{1,1,1},dist},{dist,1,5}],ContourStyle->{"TerreVerte",Opacity[.7]},BoundaryStyle->Thick] ![enter image description here][9] ## Coordination polyhedra ## You can automatically search for and plot coordination polyhedra. This is not limited to the commonly occurring tetrahedra and octahedra - you can actually look for polyhedra with arbitrary numbers of corners. There are also options to fine-tune both the searching and the rendering. plot[corners_,mixed_]:=CrystalPlot[{{0,0,0},{0,0,1.8},{-.9,-1.5,-.6},{-.9,1.5,-.6},{1.7,0,-.6},{.8,.8,.8}},{1,2,2,2,2,3}, BondStyle->False,ImageSize->250, PolyMode[corners]->{"Show"->All,"AllowMixed"->mixed},PolyStyle[corners]->Directive[Opacity[.5],EdgeForm[Thick]]]; Grid[{{ "", "Search for polyhedra with \n4 corners", "Search for polyhedra with \n5 corners" },{ "Allow \nmixed corners", plot[4,True], plot[5,True] },{ "Don't allow \nmixed corners", plot[4,False], plot[5,False] }},Dividers->All] ![enter image description here][10] CrystalPlot[{{2.5,-4.3,0},{2.5,4.3,0},{0,0,5.5}}, {{.5,0,0},{0,.5,.7},{.5,.5,.3},{.2,.4,.5},{.6,.8,.2},{.2,.8,.8},{.8,.6,.5},{.4,.2,.2},{.8,.2,.8}},{1,1,1,2,2,2,2,2,2}, PolyMode[4]->True,PolyStyle[4]->EdgeForm[None],AddQ->True, Sysdim->2,AtomRad->0,CellLineStyle->False,AtomCol->{"SlateGray","Firebrick"}, ViewAngle->.4,ViewPoint->{3.2,0,1.1},ViewVertical->{.5,0,1.2}] ![enter image description here][11] ## Other things ## Visualization aside, you can also build supercells, change cell shapes, or add, remove and sort atoms... but that's a bit boring to read, so I'll refer you to the Documentation page of the `CrystalChange` function instead. If you're interested, we can use this thread to talk about any questions you may have, or you can share your use of the package (if you decide to use it). I'm not offering full support here, but I'll be floating around, and I'd like to hear your feedback. We don't have any intentions to be involved in further development. But if you have a good idea and some time, then by all means, work on it for yourself, or host it on your favourite code collaboration site. Bianca Eifert and Christian Heiliger [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=teaser.png&userId=69107 [2]: http://library.wolfram.com/infocenter/MathSource/9372/ [3]: http://library.wolfram.com/infocenter/MathSource/9373/ [4]: http://library.wolfram.com/infocenter/MathSource/9375/ [5]: http://vasp.at/ [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=9692simple.png&userId=69107 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=atoms.png&userId=69107 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=bonds.png&userId=69107 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=planes.png&userId=69107 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=polys.png&userId=69107 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=polys2.png&userId=69107 [12]: http://rruff.geo.arizona.edu/AMS/CIF_text_files/13532_cif.txt [13]: http://cms.mpi.univie.ac.at/vasp/vasp/POSCAR_file.html [14]: http://wiki.jmol.org/index.php/File:Caffeine.mol Bianca Eifert 2016-02-05T18:43:18Z https://community.wolfram.com/groups/-/m/t/457288 [](https://gitter.im/MaTeX-help/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [](https://github.com/szhorvat/MaTeX/releases) [](https://github.com/szhorvat/MaTeX/releases) [](https://github.com/szhorvat/MaTeX/issues) [](https://zenodo.org/badge/latestdoi/31675019) ---- Hello everyone, I wrote a package that makes it easy to insert LaTeX-typeset formulae in Mathematica notebooks, in particular in Mathematica graphics. I use this to create figures with high quality typesetting that fit well with the visual style of LaTeX documents. Here's the [package description][1] and here's [MaTeX][2]. Features of the package: - get LaTeX-typeset snippets as Mathematica `Graphics` expressions (convenient for a Mathematica-centric workflow) - the baseline is preserved so these snippets can be precisely aligned with each other or with Mathematica text - control over font size, magnification and display or inline styles - integrated documentation (open the documentation centre and search for "MaTeX") Let me know what you think and whether you find it useful. A quick demo: <img src="http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2017-09-0111.08.27.png&userId=38370" width="772"> [1]: http://szhorvat.net/pelican/latex-typesetting-in-mathematica.html [2]: https://github.com/szhorvat/MaTeX [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Screenshot2017-09-0111.08.27.png&userId=38370 Szabolcs Horvát 2015-03-12T01:39:42Z https://community.wolfram.com/groups/-/m/t/2328597 > **GitHub Repository:** https://github.com/alecGraves/Howl &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/da6d3b76-7bbf-4a55-9fcd-058e7f1e17bf Alec Graves 2021-07-27T14:09:12Z https://community.wolfram.com/groups/-/m/t/762950 **RadarChart Mathematica Package** The *RadarChart* mathematica package incorporates Radar Charts (also known as Spider Charts, Web Charts and Star Plots) as a new set of visualization tools into the mathematica environment. A detailed explanation on the use of radar charts can be found in the following [wikipedia page](https://en.wikipedia.org/wiki/Radar_chart). The project is listed at the mathematica package repository ([http://packagedata.net][1]), or can be accessed directly at [github][2]. Thanks to [halirutan](https://github.com/halirutan) for his guidance on setting up this project. Installation Instructions are heavily based on his existing projects. --- **Navigation** - [Detailed Usage](#-detailed-usage) - [Examples](#examples) - [Neat Examples](#neat-examples) - [Installation](#installation) - [Automatic Installation for *Mathematica* 9 and above](#automatic-installation-for-mathematica-9-and-above) - [Manual Installation](#manual-installation) - [Contact](#-contact) --- ## Detailed Usage RadarChart[{y1,y2,y3,...}] generates a radar plot (also known as web, star, spider, cobweb or kiviat diagram) corresponding to a list of values. This type of chart is suitable for showing commonality and outliers across different variables. RadarChart[{list1,list2,...}] generates a radar plot to compare several series. RadarChart[association] generates a radar plot to view the variable values in an association. RadarChart[{association1,association2,...}] generates a radar plot to compare several series. RadarChart[dataset] generates a radar plot to compare several series. Options are listed in the help file, and also in the readme document @ the github site. ##Examples Needs["RadarChart`"] RadarChart[{1, 2, 4, 5, 3}, ChartLegends -> {"Private Label Strawberry Juice"}, AxesLabel -> {"Ripe", "Green", "Candy", "Juicy", "Sulphur"}, PlotLabel -> Style["Sensory Map Strawberry Juice", Bold, Large], ImageSize -> Medium]  Multiple Series can be charted. Needs["RadarChart`"] RadarChart[{{1, 4, 3, 5, 2}, {2, 4, 3, 2, 1}}, Filling -> Axis, AxesLabel -> {"Sweet", "Sour", "Salty", "Bitter", "Umami"}, PlotStyle -> {Red, Blue}, ChartLegends -> {"Fernet-Cola", "Jugo"}]  Example of a start plot. Needs["RadarChart`"]; RadarChart[{{1, 4, 3, 5, 2}, {2, 4, 3, 2, 1}}, AxesType -> "Star"]  Compare survey results. Needs["RadarChart`"]; RadarChart[{{3, 4, 3, 4, 2}, {4, 5, 4, 5, 3}}, AxesLabel -> {"Assets", "Reliability", "Cost Control", "Abstenteeism", "Revenue"}, ChartLegends -> {"Past Year", "Current Year"}, Filling -> Axis, PlotStyle -> {{Gray}, {Black}}, ImageSize -> Medium]  ##Neat Examples Analyze and compare crime statistics across states. Needs["RadarChart`"]; states = EntityClass["AdministrativeDivision", "AllUSStatesPlusDC"]; stateNames = First@StringSplit[#, ","] & /@ states["Name"]; crimeProps = {"AggravatedAssaultRate", "BurglaryRate", "ForcibleRapeRate", "LarcenyTheftRate", "MurderNonnegligentManslaughterRate", "PropertyCrimeRate", "RobberyRate", "ViolentCrimeRate"}; crimeData = EntityValue[states, EntityProperty["AdministrativeDivision", #] & /@ crimeProps]; crimeRanking = Transpose[ Ordering[crimeData[[All, #]]] & /@ Range@Length@crimeProps]; ds = Dataset[ AssociationThread[stateNames, AssociationThread[crimeProps, #] & /@ crimeRanking]]; GraphicsRow[{RadarChart[ds["Georgia"], AxesType -> "Star", PlotLabel -> Style["Georgia", Bold, Large], Epilog -> {Dashed, Circle[{0, 0}, 25.5]}, ImageSize -> Large], GraphicsGrid[ Partition[ RadarChart[ds[#], PlotLabel -> #, AxesLabel -> None, PlotRange -> {0, 50}, AxesType -> "Star", PlotRangePadding -> Full, FrameTicks -> None, Epilog -> {Dashed, Circle[{0, 0}, 25.5]}] & /@ stateNames, UpTo[6]], ImageSize -> 600]}]]  #Installation This package should work with Mathematica >8 if not using associations or datasets. The package was developed using mathematica 10. The installation is simple: Copy the `RadarChart` package directory into a location where *Mathematica* can find it. Usually this is the `Applications` directory in your `$UserBaseDirectory`. Just evaluate FileNameJoin[{$UserBaseDirectory, "Applications"}] to see it. If there is an old installation of the `RadarChart`, remove it. Please find detailed steps below. ###Automatic Installation for *Mathematica* 9 and above We have set up [an installation script](https://raw.githubusercontent.com/catrasca/RadarChart/master/RadarChart/installer.m) that does all the steps, except deleting old installations, for you. If it finds an old installation, it will prompt you with the location and quit, so that you can remove the old installation. After removing the old files, just start it again and it will proceed through all the steps pointed out in the manual installation section. To start the installation script, simply call Import["http://tinyurl.com/ntmhkca"] After this, the package should be available in your mathematica instance. ###Manual Installation ####Removing old Installations Old installation packages can be found by simply searching directories in your `$Path`. FileNames["RadarChart", $Path] Please remove old installation directories that appear after evaluating the commands above. You can use DeleteDirectory[dir, DeleteContents -> True] for that, but note that on Windows this might fail, because there, some files are locked when *Mathematica* is running. In this case, close *Mathematica* and do it manually using an explorer. ###Downloading, Extracting and Copying the New Version The easiest way is, to download the whole repository as zip file. Use [this master.zip](https://github.com/catrasca/RadarChart/archive/master.zip) or click the *Download ZIP* on the right side on this page. After you have downloaded the file extract it. If you have no tool for this on Windows, you could use the [free 7-Zip](http://7-zip.org/). Under Mac OSX and Linux this should work out of the box. Inside the extracted directory, you will find a subdirectory `RadarChart` which has the following structure RadarChart/ ??? Documentation ? ??? English ? ??? ReferencePages ? ??? Symbols ? ??? RadarChart.nb ??? Kernel ? ??? init.m ??? Installer.m ??? pacletInfo.m ??? RadarChart.m Copy the whole `RadarChart` directory with all its content to your `Applications` folder under your `$UserBaseDiretory`. If everything is in place proceed to the next step. ###Finishing the Installation To make the package works, you can simply restart *Mathematica*. ## Contact If you find bugs or have any other questions, please [create a new issue](https://github.com/catrasca/RadarChart/issues) in the bug-tracker. [1]: http://packagedata.net/ [2]: http://github.com/catrasca/RadarChart Diego Zviovich 2015-12-22T20:02:41Z https://community.wolfram.com/groups/-/m/t/1646303 # UNET [](https://zenodo.org/badge/latestdoi/137186334) [](https://github.com/dwyl/esta/issues) ---------- ![Automated 3D muscle segmentation using UNET / RESNET using DIXON MRI data][17] A package to generate and train a UNET deep convolutional network for 2D and 3D image segmentation. Some code was based on [work][1] by [@Ali Hashmi][at0], which was also dicussed in [this post][2] The full version of the toolbox can be found on my [github page][3]. * [Information](#information) * [Install toolbox](#install-toolbox) * [Using the toolbox](#using-the-toolbox) * [Functionality](#functionality) * [Visualization](#visualization) * [Example](#example) ## Information UNET is developed for [Mathematica](https://www.wolfram.com/mathematica/). It contains the following toolboxes: - UnetCore - UnetSupport Documentation of all functions and their options is fully integrated in the Mathematica documentation. The toolbox always works within the latest version of Mathematica and does not support any backward compatibility. All code and documentation is maintained and uploaded to github using [Workbench](https://www.wolfram.com/workbench/). ## Install toolbox Install the toolbox in the Mathematica UserBaseDirectory > Applications. FileNameJoin[{$UserBaseDirectory, "Applications"}] ## Using the toolbox The toolbox can be loaded by using <<UNET` The notbook ``UNET.nb`` shows examples of how to use the toolbox on artificially generated 2D data. There are also examples how to visualize the layer of your trained network and how to visualize the training itself. ## Functionality The network supports multi channel inputs and multi class segmentation. * UNET generates a UNET convolutional network. * 2D UNET ![UNET 2D][4] * 3D UNET ![UNET 3D][5] * Loss Layers: Training the data is done using three loss layers: a SoftDiceLossLayer, BrierLossLayer and a CrossEntropyLossLayer. ![SoftDiceLossLayer, BrierLossLayer and a CrossEntropyLossLayer][6] * Convolution Blocks: The toobox contains five different convolution blocks that build up the network: [UNET][7], UResNet, [RestNet][8], UDenseNet, [DensNet][9]. ![Convolution blocks][10] * SplitTrainData splits the data and labels into training, validation and test data. ![split train Data][11] * TrainUNET trains the network. ![Train UNET][12] ## Visualization * Visualize the network and results. * Visualize the features of the layers. ![Visualize layer features][13] * Visualize the results. ![Visualize the results][14] * Animate the training process. ![UNET 2D animation][15] ![UNET 3D animation][16] ## Example * Example: 3D segmentation of lower legg muscles using MRI data. ![Automated 3D muscle segmentation using UNET / RESNET using DIXON MRI data][17] [1]: https://github.com/alihashmiii/UNet-Segmentation-Wolfram [2]: https://community.wolfram.com/groups/-/m/t/1341081?p_p_auth=w8PIeeiA [3]: https://github.com/mfroeling [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=UNET2D.PNG&userId=1332602 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=UNET3D.PNG&userId=1332602 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Loss.PNG&userId=1332602 [7]: https://arxiv.org/abs/1505.04597 [8]: https://arxiv.org/abs/1512.03385 [9]: https://arxiv.org/abs/1608.06993 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=convblocks.PNG&userId=1332602 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Split.PNG&userId=1332602 [12]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Train.PNG&userId=1332602 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Visualize1.PNG&userId=1332602 [14]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Visualize2.PNG&userId=1332602 [15]: https://community.wolfram.com//c/portal/getImageAttachment?filename=amin0-v2.gif&userId=1332602 [16]: https://community.wolfram.com//c/portal/getImageAttachment?filename=amin4-v2.gif&userId=1332602 [17]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Muscle_Segmentation.jpg&userId=1332602 [at0]: https://community.wolfram.com/web/alihashmi87 Martijn Froeling 2019-04-03T20:01:26Z https://community.wolfram.com/groups/-/m/t/1273720 ## Background I enjoy coding in the FrontEnd (except it crashes and lookup across files does not exist), but I often miss 'hands on keyboard', customizable code templates. E.g. I often forget to wrap an option name with quotes "_" or I'm starting a new function and would like to avoid retyping `Attributes/Options` `Catch/Check` etc. I don't like palettes for something that I need to do quickly and frequently. The are not 'hands on keyboard' either. So I created a little package/stylesheet, should work on Win/MacOs with MMA 10.4+ https://github.com/kubaPod/DevTools In case you are interested and/or have any ideas about this / similar features, let me know here or create an Issue in GitHub. Topic cross posted on Mathematica.stackexchange: https://mathematica.stackexchange.com/q/164653/5478 [![enter image description here][2]][2] ## Index Most up to date examples, setup and other details can be found in [**project's Readme.MD**](https://github.com/kubaPod/DevTools) - [v0.10.0 (01-12-2018) NotebookActions](https://community.wolfram.com/groups/-/m/t/1273720#lukr_reply) - [v0.8.0 (06-07-2018) VerificationTest template](https://community.wolfram.com/groups/-/m/t/1273720#kxdi_reply) - [v0.7.0 (21-02-2018) support for V10.4](https://community.wolfram.com/groups/-/m/t/1273720#gkow_reply) [2]: https://i.stack.imgur.com/g96TY.gif Kuba Podkalicki 2018-01-28T18:00:23Z https://community.wolfram.com/groups/-/m/t/147140 [b]Disclaimer:[/b] I am one of the MATLink developers. Some of you have already seen it, but for those that haven't, I would like to present the [url=http://matlink.org/]MATLink package available at matlink.org[/url]: [url=http://matlink.org/][img=width: 250px; height: 145px;]/c/portal/getImageAttachment?filename=logo.png&userId=38370[/img][/url] This package makes it possible to transfer data between Mathematica and MATLAB as well as seamlessly call MATLAB functions from Mathematica.  Some example applications are shown as [url=http://matlink.org/examples/]http://matlink.org/examples/ [/url] As of version 1.0, the package can: [list] [*]Transfer data (variables) between the two systems in both directions.  Most MATLAB data structures are supported, including sparse arrays, cells and structs. [*]Wrap MATLAB functions in the MFunction head and call them directly.  Arguments and return values are translated automatically. [*]It works on all three common platforms (Windows, Mac, Linux). [/list]Note that version 1.0 does not make it possible to call Mathematica functions from MATLAB, only the reverse.  It is useful if Mathematica is your primary work environment but you need to use some MATLAB functionality in your Mathematica code. Here's a transcript of a short MATLink session as a deomonstration: [mcode] In[1]:= << MATLink` In[2]:= OpenMATLAB[] (* start MATLAB *) In[3]:= mat = RandomReal[1, {5, 5}]; (* create random matrix *) In[4]:= MEvaluate["help eig"] (* get help on the eig() MATLAB function *) Out[4]= ">> EIG Eigenvalues and eigenvectors.     E = EIG(X) is a vector containing the eigenvalues of a square      matrix X.   ... " In[5]:= MFunction["eig"][mat] (* calculate eigenvalues using MATLAB *) Out[5]= {{2.62592 + 0. I}, {-0.0575 + 0.555101 I}, {-0.0575 - 0.555101 I}, {0.558724 + 0. I}, {0.128974 + 0. I}} In[6]:= Sort@Flatten[%] == Sort@Eigenvalues[mat] (* check that the result is the same that Mathematica gives *) Out[6]= True [/mcode] Szabolcs Horvát 2013-11-01T17:54:28Z https://community.wolfram.com/groups/-/m/t/1421180 Two months ago, Albert Rich posted ["What's the hardest integral Mathematica running Rubi can find?"](http://community.wolfram.com/groups/-/m/t/1343015) here on the Wolfram Community. You might have also seen that I responded in detail, and pointed out a few things that could help improve Rubi (Rule-based integrator). While it appears nothing really happened afterward, this is far from reality. Since then, Albert and I have worked closely together to make Rubi more accessible and user-friendly. If you would like to learn how our productive collaboration evolved, let me invite you to read [my latest blog-post](http://halirutan.de/programming/Rubi/). However, here, we want to share an update that should serve as an overview of what we have done to improve Rubi. First of all, Rubi has got a new home under [rulebasedintegration.org](https://rulebasedintegration.org/), and its old website will no longer be updated. On the new website, you will find information, installation instructions, and links to the source-code and test-suites. Secondly, we created a [Rubi Organization](https://github.com/RuleBasedIntegration) on GitHub that serves as the headquarters for all things Rubi. It contains all Rubi's code, notebooks, and test-suites nicely structured into several repositories. At the moment, we provide repositories for the * loadable package files and notebook source files defining over 6700 integration rules, * PDF files displaying the rules in human-readable mathematical notation alongside the Mathematica code, and * test-suite files containing over 71000 integration problems and their solutions. The integration test files are available in the syntax used by 4 popular computer algebra systems (Mathematica, Maple, Maxima, and Axiom). The test-suite can be used to compare Rubi's results with other symbolic integrators, including Mathematica's `Integrate` function. In addition to the transition to GitHub, we recently released version 4.16.0.3 of Rubi which significantly expands the class of expressions the system can integrate. But the most noticeable change for users is the completely reworked display of the rules and intermediate steps Rubi uses to integrate expressions. Although installation, usage, and examples are given on [Rubi's website](https://rulebasedintegration.org/), let me show you how easy it is to install and run Rubi 4.16.0.3 using Mathematica 11.3: The command PacletInstall["https://github.com/RuleBasedIntegration/Rubi/releases/download/4.16.0.3/Rubi-4.16.0.3.paclet"]; installs the Rubi-4.16.0.3 paclet on your computer. After that, to load Rubi into Mathematica all you have to do is issue the `Get` command << Rubi` Then to integrate an expression with respect to a variable, use Rubi's `Int` command similar to Mathematica's `Integrate` command. For example, evaluating Int[(Sec[x]^2 + Sec[x]^2*Tan[x])/((2 - Tan[x])*Sqrt[1 + Tan[x]^3]), x] returns the antiderivative (a.k.a. the indefinite integral) ![enter image description here][1] Rubi's unique ability to display the steps it uses to integrate expressions is a great feature of the system. For example, the `Steps` command Steps@Int[(Sec[x]^2 + Sec[x]^2*Tan[x])/((2 - Tan[x])*Sqrt[1 + Tan[x]^3]), x] displays ![enter image description here][2] Here, in red are the rules used to integrate the expression, and in blue are the intermediate results. Each rule can be expanded to show the rule number, which directly corresponds to the index of the rule in `Int`'s list of DownValues. More importantly, you can see the conditions that have to be satisfied so the rule can be applied. ![enter image description here][3] Rubi's `Stats` command provides statistics about the integration. For example, Stats[Int[(Sec[x]^2 + Sec[x]^2*Tan[x])/((2 - Tan[x])*Sqrt[1 + Tan[x]^3]), x]] displays ![enter image description here][4] The leaf-count size of an antiderivative is a crude measure of its complexity. As you can see, Rubi's antiderivative for this integral has a leaf-count of 25. Now compare Rubi's antiderivative with that produced by Mathematica 11.3 for the same integral: Integrate[(Sec[x]^2 + Sec[x]^2*Tan[x])/((2 - Tan[x])*Sqrt[1 + Tan[x]^3]), x] ![enter image description here][5] LeafCount[%] (* 290 *) Note that not only is Mathematica's result more than 11 times the size of Rubi's, it unnecessarily involves elliptic integral functions *and* the imaginary unit. Skeptics might be inclined to ask if Rubi's dramatically simpler result is actually a valid antiderivative. Since symbolic differentiation is much easier than integration, antiderivatives can be verified correct by seeing if its derivative equals the original integrand as follows: expr = (Sec[x]^2 + Sec[x]^2*Tan[x])/((2 - Tan[x])*Sqrt[1 + Tan[x]^3]); FullSimplify[D[Int[expr, x], x] == expr] FullSimplify[D[Integrate[expr, x], x] == expr] ![enter image description here][6] As you can see Mathematica easily verifies Rubi's antiderivative correct, but has a hard time verifying its own antiderivative correct... Albert and I are working on publishing the program used to thoroughly test each new version of Rubi before being released. The test program ensures Rubi's result equals the optimal antiderivative for the over 71000 problems in the test-suite. And yes, the optimal antiderivatives have all been verified correct by differentiation. Of course, the optimal antiderivatives stored in the test-suite are actually just the simplest ones found so far. If you should find a substantially simpler antiderivative than the one in the test-suite, please report it so the test-suite can be made even harder on Rubi! If all that has got you interested in joining Rubi's community of users, check out its website or talk to us in our [Gitter chatroom](https://gitter.im/Rule-Based-Integration/Lobby). [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=10564sSs5M.png&userId=11733 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=qDtIH.png&userId=11733 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=vQ4GR.png&userId=11733 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=43t8e.png&userId=11733 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=xjKTJ.png&userId=11733 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=eCoWB.png&userId=11733 Patrick Scheibe 2018-08-24T02:50:37Z https://community.wolfram.com/groups/-/m/t/866748 ## Introduction This post describes the use of face-like diagrams to visualize multidimensional data introduced by Herman Chernoff in 1973, see [1]. The idea to use human faces in order to understand, evaluate, or easily discern (the records of) multidimensional data is very creative and inspirational. As Chernoff says in [1], the object of the idea is to "represent multivariate data, subject to strong but possibly complex relationships, in such a way that an investigator can quickly comprehend relevant information and then apply appropriate statistical analysis." It is an interesting question how useful this approach is and it seems that there at least several articles discussing that; see for example [2]. I personally find the use of Chernoff faces useful in a small number of cases, but that is probably true for many "creative" data visualization methods. Below are given both simple and more advanced examples of constructing Chernoff faces for data records using the *Mathematica* package [3]. The considered data is categorized as: 1. a small number of records, each with small number of elements; 2. a large number of records, each with less elements than Chernoff face parts; 3. a list of long records, each record with much more elements than Chernoff face parts; 4. a list of nearest neighbors or recommendations. For several of the visualizing scenarios the records of two "real life" data sets are used: Fisher Iris flower dataset [7], and "Vinho Verde" wine quality dataset [8]. For the rest of the scenarios the data is generated. A fundamental restriction of using Chernoff faces is the necessity to properly transform the data variables into the ranges of the Chernoff face diagram parameters. Therefore, proper data transformation (standadizing and rescaling) is an inherent part of the application of Chernoff faces, and this document describes such data transformation procedures (also using [3]). ### Package load The packages [3,4] are used to produce the diagrams in this post. The following two commands load them. Import["https://raw.githubusercontent.com/antononcube/\ MathematicaForPrediction/master/ChernoffFaces.m"] Import["https://raw.githubusercontent.com/antononcube/\ MathematicaForPrediction/master/MathematicaForPredictionUtilities.m"] ### Mirror This Community post mirrors the blog post ["Making Chernoff faces for data visualization"](https://mathematicaforprediction.wordpress.com/2016/06/03/making-chernoff-faces-for-data-visualization/). ## Making faces ### Just a face Here is a face produced by the function `ChernoffFace` of [3] with its simplest signature: SeedRandom[152092] ChernoffFace[] [](http://i.imgur.com/PIcrIcK.gif) Here is a list of faces: SeedRandom[152092] Table[ChernoffFace[ImageSize -> Tiny], {7}] [](http://i.imgur.com/SPWgX0r.gif) ### Proper face making The "proper" way to call ChernoffFace is to use an association for the facial parts placement, size, rotation, and color. The options are passed to Graphics. SeedRandom[2331]; ChernoffFace[ AssociationThread[ Keys[ChernoffFace["FacePartsProperties"]] -> RandomReal[1, Length[ChernoffFace["FacePartsProperties"]]]], ImageSize -> Small , Background -> GrayLevel[0.85]] [](http://i.imgur.com/wY3bgKC.gif) The Chernoff face drawn with the function `ChernoffFace` can be parameterized to be asymmetric. The parameters argument mixes (1) face parts placement, sizes, and rotation, with (2) face parts colors and (3) a parameter should it be attempted to make the face symmetric. All facial parts parameters have the range [0,1] Here is the facial parameter list: Keys[ChernoffFace["FacePartsProperties"]] (* {"FaceLength", "ForheadShape", "EyesVerticalPosition", "EyeSize", \ "EyeSlant", "LeftEyebrowSlant", "LeftIris", "NoseLength", \ "MouthSmile", "LeftEyebrowTrim", "LeftEyebrowRaising", "MouthTwist", \ "MouthWidth", "RightEyebrowTrim", "RightEyebrowRaising", \ "RightEyebrowSlant", "RightIris"} *) The order of the parameters is chosen to favor making symmetric faces when a list of random numbers is given as an argument, and to make it easier to discern the faces when multiple records are visualized. For experiments and discussion about which facial features bring better discern-ability see [2]. One of the conclusions of [2] is that eye size and eye brow slant are most decisive, followed by face size and shape. Here are the rest of the parameters (colors and symmetricity): Complement[Keys[ChernoffFace["Properties"]], Keys[ChernoffFace["FacePartsProperties"]]] (* {"EyeBallColor", "FaceColor", "IrisColor", "MakeSymmetric", \ "MouthColor", "NoseColor"} *) ### Face coloring The following code make a row of faces by generating seven sequences of random numbers in $[0,1]$, each sequence with length the number of facial parameters. The face color is assigned randomly and the face color or a darker version of it is used as a nose color. If the nose color is the same as the face color the nose is going to be shown "in profile", otherwise as a filled polygon. The colors of the irises are random blend between light brown and light blue. The color of the mouth is randomly selected to be black or red. SeedRandom[201894]; Block[{pars = Keys[ChernoffFace["FacePartsProperties"]]}, Grid[{#}] &@ Table[ChernoffFace[Join[ AssociationThread[pars -> RandomReal[1, Length[pars]]], <|"FaceColor" -> (rc = ColorData["BeachColors"][RandomReal[1]]), "NoseColor" -> RandomChoice[{Identity, Darker}][rc], "IrisColor" -> Lighter[Blend[{Brown, Blue}, RandomReal[1]]], "MouthColor" -> RandomChoice[{Black, Red}]|>], ImageSize -> 100], {7}] ] [](http://i.imgur.com/QN5Rhvf.png) ### Symmetric faces The parameter "MakeSymmetric" is by default `True`. Setting "MakeSymmetric" to true turns an incomplete face specification into a complete specification with the missing paired parameters filled in. In other words, the symmetricity is not enforced on the specified paired parameters, only on the ones for which specifications are missing. The following faces are made symmetric by removing the facial parts parameters that start with "R" (for "Right") and the parameter "MouthTwist". SeedRandom[201894]; Block[{pars = Keys[ChernoffFace["FacePartsProperties"]]}, Grid[{#}] &@Table[( asc = Join[AssociationThread[ pars -> RandomReal[1, Length[pars]]], <|"FaceColor" -> (rc = ColorData["BeachColors"][RandomReal[1]]), "NoseColor" -> RandomChoice[{Identity, Darker}][rc], "IrisColor" -> Lighter[Blend[{Brown, Blue}, RandomReal[1]]], "MouthColor" -> RandomChoice[{Black, Red}]|>]; asc = Pick[asc, StringMatchQ[Keys[asc], x : (StartOfString ~~ Except["R"] ~~ __) /; x != "MouthTwist"]]; ChernoffFace[asc, ImageSize -> 100]), {7}]] [](http://i.imgur.com/7J7vl12.png) Note that for the irises we have two possibilities of synchronization: pars = <|"LeftIris" -> 0.8, "IrisColor" -> Green|>; {ChernoffFace[Join[pars, <|"RightIris" -> pars["LeftIris"]|>], ImageSize -> 100], ChernoffFace[ Join[pars, <|"RightIris" -> 1 - pars["LeftIris"]|>], ImageSize -> 100]} [](http://i.imgur.com/8i16NUg.gif) ## Visualizing records (first round) The conceptually straightforward application of Chernoff faces is to visualize ("give a face" to) each record in a dataset. Because the parameters of the faces have the same ranges for the different records, proper rescaling of the records have to be done first. Of course standardizing the data can be done before rescaling. First let us generate some random data using different distributions: SeedRandom[3424] {dists, data} = Transpose@Table[( rdist = RandomChoice[{NormalDistribution[RandomReal[10], RandomReal[10]], PoissonDistribution[RandomReal[4]], GammaDistribution[RandomReal[{2, 6}], 2]}]; {rdist, RandomVariate[rdist, 12]}), {10}]; data = Transpose[data]; The data is generated in such a way that each column comes from a certain probability distribution. Hence, each record can be seen as an observation of the variables corresponding to the columns. This is how the **columns** of the generated data look like using `DistributionChart`: DistributionChart[Transpose[data], ChartLabels -> Placed[MapIndexed[ Grid[List /@ {Style[#2[[1]], Bold, Red, Larger]}] &, dists], Above], ChartElementFunction -> "PointDensity", ChartStyle -> "SandyTerrain", ChartLegends -> dists, BarOrigin -> Bottom, GridLines -> Automatic, ImageSize -> 900] [](http://i.imgur.com/iXQfzZG.gif) At this point we can make a face for each **record** of the rescaled data: faces = Map[ChernoffFace, Transpose[Rescale /@ Transpose[data]]]; and visualize the obtained faces in a grid. Row[{Grid[ Partition[#, 4] &@Map[Append[#, ImageSize -> 100] &, faces]], " ", Magnify[#, 0.85] &@ GridTableForm[ List /@ Take[Keys[ChernoffFace["FacePartsProperties"]], Dimensions[data][[2]]], TableHeadings -> {"Face part"}] }] [](http://i.imgur.com/LMTsbCf.gif) (The table on the right shows which facial parts are used for which data columns.) ## Some questions to consider Several questions and observations arise from the example in the previous section. #### 1. What should we do if the data records have more elements than facial parts parameters of the Chernoff face diagram? This is another fundamental restriction of Chernoff faces -- the number of data columns is limiter by the number of facial features. One way to resolve this is to select important variables (columns) of the data; another is to represent the records with a vector of statistics. The latter is shown in the section "Chernoff faces for lists of long lists". #### 2. Are there Chernoff face parts that are easier to perceive or judge than others and provide better discern-ability for large collections of records? Research of the [pre-attentiveness](https://en.wikipedia.org/wiki/Pre-attentive_processing) and effectiveness with Chernoff faces, [2], shows that eye size and eyebrow slant are the features that provide best discern-ability. Below this is used to select some of the variable-to-face-part correspondences. #### 3. How should we deal with outliers? Since we cannot just remove the outliers from a record -- we have to have complete records -- we can simply replace the outliers with the minimum or maximum values allowed for the corresponding Chernoff face feature. (All facial features of `ChernoffFace` have the range $[0,1]$.) See the next section for an example. ## Data standardizing and rescaling Given a full array of records, we most likely have to standardize and rescale the columns in order to use the function `ChernoffFace`. To help with that the package [3] provides the function `VariablesRescale` which has the options "StandardizingFunction" and "RescaleRangeFunction". Consider the following example of `VariableRescale` invocation in which: 1. each column is centered around its median and then divided by the inter-quartile half-distance (quartile deviation), 2. followed by clipping of the outliers that are outside of the disk with radius 3 times the quartile deviation, and 3. rescaling to the unit interval. rdata = VariablesRescale[N@data, "StandardizingFunction" -> (Standardize[#, Median, QuartileDeviation] &), "RescaleRangeFunction" -> ({-3, 3} QuartileDeviation[#] &)]; TableForm[rdata /. {0 -> Style[0, Bold, Red], 1 -> Style[1, Bold, Red]}] [](http://i.imgur.com/LdhvQJM.png) **Remark:** The bottom outliers are replaced with 0 and the top outliers with 1 using `Clip`. ## Chernoff faces for a small number of short records In this section we are going use the Fisher Iris flower data set [7]. By "small number of records" we mean few hundred or less. ### Getting the data These commands get the Fisher Iris flower data set shipped with *Mathematica*: irisDataSet = Map[Flatten, List @@@ ExampleData[{"MachineLearning", "FisherIris"}, "Data"]]; irisColumnNames = Most@Flatten[ List @@ ExampleData[{"MachineLearning", "FisherIris"}, "VariableDescriptions"]]; Dimensions[irisDataSet] (* {150, 5} *) Here is a summary of the data: Grid[{RecordsSummary[irisDataSet, irisColumnNames]}, Dividers -> All, Alignment -> Top] [](http://i.imgur.com/upxeRHv.png) ### Simple variable dependency analysis Using the function `VariableDependenceGrid` of the package [4] we can plot a grid of variable cross-dependencies. We can see from the last row and column that "Petal length" and "Petal width" separate setosa from versicolor and virginica with a pretty large gap. Magnify[#, 1] &@ VariableDependenceGrid[irisDataSet, irisColumnNames, "IgnoreCategoricalVariables" -> False] [](http://i.imgur.com/vJA6kth.png) ### Chernoff faces for Iris flower records Since we want to evaluate the usefulness of Chernoff faces for discerning data records groups or clusters, we are going to do the following steps. 1. Data transformation. This includes standardizing and rescaling and selection of colors. 2. Make a Chernoff face for each record **without** the label class "Species of iris". 3. Plot shuffled Chernoff faces and attempt to visually cluster them or find patterns. 4. Make a Chernoff face for each record using the label class "Specie of iris" to color the faces. (Records of the same class get faces of the same color.) 5. Compare the plots and conclusions of step 2 and 4. #### 1. Data transformation First we standardize and rescale the data: chernoffData = VariablesRescale[irisDataSet[[All, 1 ;; 4]]]; These are the colors used for the different species of iris: faceColorRules = Thread[Union[ irisDataSet[[All, -1]]] \ -> Map[Lighter[#, 0.5] &, {Purple, Blue, Green}]] (* {"setosa" -> RGBColor[0.75, 0.5, 0.75], "versicolor" -> RGBColor[0.5, 0.5, 1.], "virginica" -> RGBColor[0.5, 1., 0.5]} *) Add the colors to the data for the faces: chernoffData = MapThread[ Append, {chernoffData, irisDataSet[[All, -1]] /. faceColorRules}]; Plot the distributions of the rescaled variables: DistributionChart[ Transpose@chernoffData[[All, 1 ;; 4]], GridLines -> Automatic, ChartElementFunction -> "PointDensity", ChartStyle -> "SandyTerrain", ChartLegends -> irisColumnNames, ImageSize -> Large] [](http://i.imgur.com/rwm71tn.gif) #### 2. Black-and-white Chernoff faces Make a black-and-white Chernoff face for each record without using the species class: chfacesBW = ChernoffFace[ AssociationThread[{"NoseLength", "LeftEyebrowTrim", "EyeSize", "LeftEyebrowSlant"} -> Most[#]], ImageSize -> 100] & /@ chernoffData; Since "Petal length" and "Petal width" separate the classes well for those columns we have selected the parameters "EyeSize" and "LeftEyebrowSlant" based on [2]. #### 3. Finding patterns in a collection of faces Combine the faces into a image collage: ImageCollage[RandomSample[chfacesBW], Background -> White] [](http://i.imgur.com/zmBSQZR.gif) We can see that faces with small eyes tend have middle-lowered eyebrows, and that faces with large eyes tend to have middle raised eyebrows and large noses. #### 4. Chernoff faces colored by the species Make a Chernoff face for each record using the colors added to the rescaled data: chfaces = ChernoffFace[ AssociationThread[{"NoseLength", "LeftEyebrowTrim", "EyeSize", "LeftEyebrowSlant", "FaceColor"} -> #], ImageSize -> 100] & /@ chernoffData; Make an image collage with the obtained faces: ImageCollage[chfaces, Background -> White] [](http://i.imgur.com/uPBZJuf.gif) #### 5. Comparison We can see that the collage with colored faces completely explains the patterns found in the black-and-white faces: setosa have smaller petals (both length and width), and virginica have larger petals. ## Browsing a large number of records with Chernoff faces If we have a large number of records each comprised of a relative small number of numerical values we can use Chernoff faces to browse the data by taking small subsets of records. Here is an example using "Vinho Verde" wine quality dataset [8]. [](http://i.imgur.com/jDwXgfT.png) [](http://i.imgur.com/ZOqwuFT.png) ## Chernoff faces for lists of long lists In this section we consider data that is a list of lists. Each of the lists (or rows) is fairly long and represents values of the same variable or process. If the data is a full array, then we can say that in this section we deal with transposed versions of the data in the previous sections. Since each row is a list of many elements visualizing the rows directly with Chernoff faces would mean using a small fraction of the data. A natural approach in those situations is to summarize each row with a set of descriptive statistics and use Chernoff faces for the row summaries. The process is fairly straightforward; the rest of the section gives concrete code steps of executing it. ### Data generation Here we create 12 rows of 200 elements by selecting a probability distribution for each row. SeedRandom[1425] {dists, data} = Transpose@Table[( rdist = RandomChoice[{NormalDistribution[RandomReal[10], RandomReal[10]], PoissonDistribution[RandomReal[4]], GammaDistribution[RandomReal[{2, 6}], 2]}]; {rdist, RandomVariate[rdist, 200]}), {12}]; Dimensions[data] (* {12, 200} *) We have the following 12 "records" each with 200 "fields": DistributionChart[data, ChartLabels -> MapIndexed[ Row[{Style[#2[[1]], Red, Larger], " ", Style[#1, Larger]}] &, dists], ChartElementFunction -> ChartElementData["PointDensity", "ColorScheme" -> "SouthwestColors"], BarOrigin -> Left, GridLines -> Automatic, ImageSize -> 1000] [](http://i.imgur.com/HJWZo6T.gif) Here is the summary of the records: Grid[ArrayReshape[RecordsSummary[Transpose@N@data], {3, 4}], Dividers -> All, Alignment -> {Left}] [](http://i.imgur.com/HmIUX0d.png) ### Data transformation Here we "transform" each row into a vector of descriptive statistics: statFuncs = {Mean, StandardDeviation, Kurtosis, Median, QuartileDeviation, PearsonChiSquareTest}; sdata = Map[Through[statFuncs[#]] &, data]; Dimensions[sdata] (* {12, 6} *) Next we rescale the descriptive statistics data: sdata = VariablesRescale[sdata, "StandardizingFunction" -> (Standardize[#, Median, QuartileDeviation] &)]; For kurtosis we have to do special rescaling if we want to utilize the property that Gaussian processes have kurtosis 3: sdata[[All, 3]] = Rescale[#, {3, Max[#]}, {0.5, 1}] &@Map[Kurtosis, N[data]]; Here is the summary of the columns of the rescaled descriptive statistics array: Grid[{RecordsSummary[sdata, ToString /@ statFuncs]}, Dividers -> All] [](http://i.imgur.com/SHbLThq.png) ### Visualization First we define a function that computes and tabulates (descriptive) statistics over a record. Clear[TipTable] TipTable[vec_, statFuncs_, faceParts_] := Block[{}, GridTableForm[ Transpose@{faceParts, statFuncs, NumberForm[Chop[#], 2] & /@ Through[statFuncs[vec]]}, TableHeadings -> {"FacePart", "Statistic", "Value"}]] /; Length[statFuncs] == Length[faceParts]; To visualize the descriptive statistics of the records using Chernoff faces we have to select appropriate facial features. faceParts = {"NoseLength", "EyeSize", "EyeSlant", "EyesVerticalPosition", "FaceLength", "MouthSmile"}; TipTable[First@sdata, statFuncs, faceParts] [](http://i.imgur.com/bEOFgXH.png) One possible visualization of all records is with the following commands. Note the addition of the parameter "FaceColor" to also represent how close a standardized row is to a sample from Normal Distribution. {odFaceColor, ndFaceColor} = {White, ColorData[7, "ColorList"][[8]]}; Grid[ArrayReshape[Flatten@#, {4, 3}, ""], Dividers -> All, Alignment -> {Left, Top}] &@ MapThread[ (asc = AssociationThread[faceParts -> #2]; chFace = ChernoffFace[ Join[asc, <| "FaceColor" -> Blend[{odFaceColor, ndFaceColor}, #2[[-1]]], "IrisColor" -> GrayLevel[0.8], "NoseColor" -> ndFaceColor|>], ImageSize -> 120, AspectRatio -> Automatic]; tt = TipTable[N@#3, Join[statFuncs, {Last@statFuncs}], Join[faceParts, {"FaceColor"}]]; Column[{Style[#1, Red], Grid[{{Magnify[#4, 0.8], Tooltip[chFace, tt]}, {Magnify[tt, 0.7], SpanFromAbove}}, Alignment -> {Left, Top}]}]) & , {Range[Length[sdata]], sdata, data, dists}] [](http://i.imgur.com/CGVbZck.png) ## Visualizing similarity with nearest neighbors or recommendations ### General idea Assume the following scenario: 1. we have a set of items (movies, flowers, etc.), 2. we have picked one item, 3. we have computed the Nearest Neighbors (NNs) of that item, and 4. we want to visualize how much of a good fit the NNs are to the picked item. Conceptually we can translate the phrase "how good the found NNs (or recommendations) are" to: * "how similar the NNs are to the selected item", or * "how different the NNs are to the selected item." If we consider the picked item as the prototype of the most normal or central item then we can use Chernoff faces to visualize item's NNs deviations. **Remark:** Note that Chernoff faces provide similarity visualization most linked to Euclidean distance that to other distances. ### Concrete example The code in this section demonstrates how to visualize nearest neighbors by Chernoff faces variations. First we create a nearest neighbors finding function over the Fisher Iris data set (without the species class label): irisNNFunc = Nearest[irisDataSet[[All, 1 ;; -2]] -> Automatic, DistanceFunction -> EuclideanDistance] Here are nearest neighbors of some random row from the data. itemInd = 67; nnInds = irisNNFunc[irisDataSet[[itemInd, 1 ;; -2]], 20]; We can visualize the distances with of the obtained NNs with the prototype: ListPlot[Map[ EuclideanDistance[#, irisDataSet[[itemInd, 1 ;; -2]]] &, irisDataSet[[nnInds, 1 ;; -2]]]] [](http://i.imgur.com/dnUlWSD.gif) Next we subtract the prototype row from the NNs data rows, we standardize, and we rescale the interval $[ 0, 3 \sigma ]$ to $[ 0.5, 1 ]$: snns = Transpose@Map[ Clip[Rescale[ Standardize[#, 0 &, StandardDeviation], {0, 3}, {0.5, 1}], {0, 1}] &, Transpose@ Map[# - irisDataSet[[itemInd, 1 ;; -2]] &, irisDataSet[[nnInds, 1 ;; -2]]]]; Here is how the original NNs data row look like: GridTableForm[ Take[irisDataSet[[nnInds]], 12], TableHeadings -> irisColumnNames] [](http://i.imgur.com/7r6habk.png) And here is how the rescaled NNs data rows look like: GridTableForm[Take[snns, 12], TableHeadings -> Most[irisColumnNames]] [](http://i.imgur.com/P7xnwR5.png) Next we make Chernoff faces for the rescaled rows and present them in a easier to grasp way. We use the face parts: Take[Keys[ChernoffFace["FacePartsProperties"]], 4] (* {"FaceLength", "ForheadShape", "EyesVerticalPosition", "EyeSize"} *) To make the face comparison easier, the first face is the one of the prototype, each Chernoff face is drawn within the same rectangular frame, and the NNs indices are added on top of the faces. chfaces = ChernoffFace[#, Frame -> True, PlotRange -> {{-1, 1}, {-2, 1.5}}, FrameTicks -> False, ImageSize -> 100] & /@ snns; chfaces = MapThread[ ReplacePart[#1, 1 -> Append[#1[[1]], Text[Style[#2, Bold, Red], {0, 1.4}]]] &, {chfaces, nnInds}]; ImageCollage[chfaces, Background -> GrayLevel[0.95]] [](http://i.imgur.com/EKpJ7mj.gif) We can see that the first few - i.e. closest -- NNs have fairly normal looking faces. Note that using a large number of NNs would change the rescaled values and in that way the first NNs would appear more similar. ## References \[1\] Herman Chernoff (1973). "The Use of Faces to Represent Points in K-Dimensional Space Graphically" (PDF). Journal of the American Statistical Association (American Statistical Association) 68 (342): 361-368. doi:10.2307/2284077. JSTOR 2284077. URL: [http://lya.fciencias.unam.mx/rfuentes/faces-chernoff.pdf](http://lya.fciencias.unam.mx/rfuentes/faces-chernoff.pdf) . \[2\] Christopher J. Morris; David S. Ebert; Penny L. Rheingans, "Experimental analysis of the effectiveness of features in Chernoff faces", Proc. SPIE 3905, 28th AIPR Workshop: 3D Visualization for Data Exploration and Decision Making, (5 May 2000); doi: 10.1117/12.384865. URL: [http://www.research.ibm.com/people/c/cjmorris/publications/Chernoff_990402.pdf](http://www.research.ibm.com/people/c/cjmorris/publications/Chernoff_990402.pdf) . \[3\] Anton Antonov, [Chernoff Faces implementation in Mathematica](https://github.com/antononcube/MathematicaForPrediction/blob/master/ChernoffFaces.m), (2016), source code at [MathematicaForPrediction at GitHub](https://github.com/antononcube/MathematicaForPrediction), package [ChernofFacess.m](https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/master/ChernoffFaces.m) . \[4\] Anton Antonov, [MathematicaForPrediction utilities](https://github.com/antononcube/MathematicaForPrediction/blob/master/MathematicaForPredictionUtilities.m), (2014), source code [MathematicaForPrediction at GitHub](https://github.com/antononcube/MathematicaForPrediction), package [MathematicaForPredictionUtilities.m](https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/master/MathematicaForPredictionUtilities.m). \[5\] Anton Antonov, [Variable importance determination by classifiers implementation in Mathematica](https://github.com/antononcube/MathematicaForPrediction/blob/master/VariableImportanceByClassifiers.m)[, ](https://github.com/antononcube/MathematicaForPrediction/blob/master/IndependentComponentAnalysis.m)(2015), source code at [MathematicaForPrediction at GitHub](https://github.com/antononcube/MathematicaForPrediction), package [VariableImportanceByClassifiers.m](https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/master/VariableImportanceByClassifiers.m). \[6\] Anton Antonov, ["Importance of variables investigation guide"](https://github.com/antononcube/MathematicaForPrediction/blob/master/Documentation/Importance-of-variables-investigation-guide.pdf), (2016), [MathematicaForPrediction at GitHub](https://github.com/antononcube/MathematicaForPrediction), [https://github.com/antononcube/MathematicaForPrediction](https://github.com/antononcube/MathematicaForPrediction), folder [Documentation](https://github.com/antononcube/MathematicaForPrediction/tree/master/Documentation). \[7\] Wikipedia entry, Iris flower data set, [https://en.wikipedia.org/wiki/Iris_flower_data _set](https://en.wikipedia.org/wiki/Iris_flower_data_set) . \[8\] P. Cortez, A. Cerdeira, F. Almeida, T. Matos and J. Reis. Modeling wine preferences by data mining from physicochemical properties. In Decision Support Systems, Elsevier, 47(4):547-553, 2009. URL [https://archive.ics.uci.edu/ml/datasets/Wine+Quality](https://archive.ics.uci.edu/ml/datasets/Wine+Quality) . Anton Antonov 2016-06-03T02:17:45Z