https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Packages with no replies sorted by most viewed. https://community.wolfram.com/groups/-/m/t/516854 Hello, I am trying to use the HadoopLink package for the first time, and running into a few challenges. I am hoping someone out there is using this successfully, and might have some tips for a smooth installation in the current version of mathematica (10.2 at the time of writing this). I have downloaded the open-source project and I am following along with [HadoopLink installation instructions on GitHub][1]. I have unpacked the .zip and placed the HadoopLink folder (and only that folder, not the entire unpacked project) into my $User/Libarary/Mathematica/Applications folder, and loaded the package using: << HadoopLink` But when I proceed to the next step, and execute this code... link = OpenHadoopLink[ "fs.default.name" -> "hdfs://hadoopheadlx.wolfram.com:8020", "mapred.job.tracker" -> "hadoopheadlx.wolfram.com:8021"]; DFSFileNames[link] Mathematica output spews a bunch of Java exceptions (attached). Anybody have more detailed instructions on setting up HadoopLink? Maybe I should have put the entire project folder into the /Applications folder instead. I will try that now... [1]: https://github.com/shadanan/HadoopLink Caitlin Ramsey 2015-06-22T15:09:06Z https://community.wolfram.com/groups/-/m/t/370172 Admit it... You always wanted to play with those motion capture files that you can find for free by the thousands on places like the [Advanced Computing Center for the Arts and Design][1] or the [cgspeed site][2] which contains BVH conversions of the 2500-motion [Carnegie-Mellon motion capture dataset][3]. Well, now you can. I have written an importer package for the BVH (Biovision hierarchical data) motion capture format, which you can find as an answer on [mathematica.stackoverflow.com][4]. Just three of the possibilities: Import: out = Import[ "C:\\Female1_D6_CartWheel.bvh"] ![enter image description here][5] Generate movies: out["AnimatedGIF", "C:\\cartwheel.gif"] ![enter image description here][6] Analyse motion: Graphics3D[ MapIndexed[ {Opacity[0.8], Hue[#2[[1]]/out["FrameCount"]], GraphicsComplex[#1, Line /@ out["Bones"]]} &, out["JointsStack"] ], Boxed -> False ] ![enter image description here][7] etc. etc. Combined with all the graphical power of Mathematica the possibilities for fun projects are endless. How about this? ![enter image description here][8] [1]: http://accad.osu.edu/research/mocap/mocap_data.htm [2]: https://sites.google.com/a/cgspeed.com/cgspeed/motion-capture [3]: http://mocap.cs.cmu.edu/ [4]: http://mathematica.stackexchange.com/a/60942/57 [5]: /c/portal/getImageAttachment?filename=6g00x.png&userId=43903 [6]: /c/portal/getImageAttachment?filename=0BflU.gif&userId=43903 [7]: /c/portal/getImageAttachment?filename=H4YIN.png&userId=43903 [8]: /c/portal/getImageAttachment?filename=mobius.gif&userId=43903 Sjoerd de Vries 2014-10-15T21:02:42Z https://community.wolfram.com/groups/-/m/t/204387 Hi, I want to share this with you. This [url=http://youtu.be/RoNr34s4A9k]video[/url] shows a completely integrated project scheduling and monitoring environment. The system has been built with these technologies:[list] [*]Smartsheet for the project scheduling [*]Mathematica for the computing of the progress reports [*]CDF Player for deploying the results [/list]The user now experiences a seamless integration of everything he needs to schedule, track and monitor a project. Everything is web based, there is no "interface switching" anymore, and everything about the progress reports generation is automated. To be honest: to step from the non web-based configuration to the present configuration, it only took a good week! Only possible with the Wolfram technologies. My guess: This is it! Greats, JP Jean Pierre Tollenboom 2014-02-21T11:04:16Z https://community.wolfram.com/groups/-/m/t/1732842 #Introduction I attended the Wolfram High School Summer Camp in the 2019 session. For my project, I attempted to implement a framework for creating, training, applying, and inspecting Tsetlin Machines. Tsetlin Machines are unique when compared with other methods of machine learning because they operate using Boolean operations on binary data, and the individual building blocks only require a single integer in memory. Compare this to the Neural Net, which operates by applying Calculus to floating point numbers, and where each neuron requires multiple pieces in memory corresponding to their activation function, bias, connections, weights of connections, etc. Tsetlin Machines also have the advantage that they are interpretable: once a Tsetlin Machine has been taught, it can be interpreted as a propositional formula, whereas Neural Networks, once taught, are famously "black boxes" that no one knows what's really happening inside. Furthermore, Tsetlin Machines can be used in mathematical research to produce satisfactory propositional formulas. This community post will provide an overview about how Tsetlin Machines work. The only code in this community post will be at the very end, where I give a short example of how a Tsetlin Machine is created and trained using my framework. My full Wolfram Language implementation can be on my github account, a link to which can found at the bottom of this community post. # Tsetlin Automata Tsetlin Machines are a kind of machine learning based on combining Tsetlin Automata to assemble a propositional formula. So, what is a Tsetlin Automaton? A Tsetlin Automaton is an extremely simple automaton that has a finite number of states ($2n$) (image below). Based on it's state, a Tsetlin Automaton can chose between 2 actions ($a_1$ and $a_2$). ("Action" here is an abstract concept that can basically represents a choice between two things.) It chooses the first action if it's current state is equal to a certain value ($n$) that I call the state identifier, and chooses the second action if it's state is above the value. So, when does a Tsetlin Automaton make this choice? Both when giving output and training. The only output ever given by a Tsetlin Automaton is its' current action. So, whenever a Tsetlin Automaton has to do pretty much anything, it starts by choosing an action and outputting it. ![tsetlin automaton][1] <sub>Image reproduced from https://arxiv.org/pdf/1804.01508.pdf</sub> Now, how does an individual Tsetlin Automaton learn? Via punishment and reward. It's pretty simple: when a Tsetlin Automaton makes a good choice, it gets rewarded (and it's current state moves farther from the point at which it would chose the other action). When it makes a bad choice, it is punished (and it's current state moves closer to the point at which it would chose the other action). Who rewards and punishes the Tsetlin Automaton? The environment. For example, imagine that a Tsetlin Automaton (let's call him Steve) has to chose between eating two kinds of chocolate, 1 and 2. Steve has 6 states ($n=3$). He starts randomly selects one to start with, and chooses the action of eating chocolate 2 (so his current state is 4). Eating this chocolate boosted his cognitive power, so he is rewarded (and his current state goes to 5). He takes another bite, but this time there is no effect, so he is punished (state goes back to 4). Another bite, and another failure leads to another punishment (his state goes to 3). Because Steve's state crossed the "action border" between eating chocolate 2 (state $>3)$) and eating chocolate 1 (state $\leq3$), his next choice is to eat chocolate 1. This does boost his cognitive power, so he is rewarded (state goes to 2). Another bite boosts his cognitive power again, and again he is rewarded (state goes to 1). At this point, Steve is pretty confident that chocolate 1 is the better option because it boosts his cognitive power more often, so he decides to stop training and stick with chocolate 1. Below is a graph of Steve's state (blue) as he learns (yellow is the "action tipping point"). <sub>The above story a work of fiction. Any resemblance to actual events or locales or persons, living or dead, is entirely coincidental.</sub> ![steve learn path][2] # Tsetlin Machines ![tsetlin machine full structure][3] <sub>Image reproduced from https://arxiv.org/pdf/1804.01508.pdf</sub> So, how do Tsetlin Automata work together to form a full Tsetlin Machine? By learning which inputs to a Tsetlin Machine are important. But before learning can be explained, the process of how a Tsetlin Machine calculates its' outputs must be explained. For this purpose, consider a Tsetlin Machine that has not yet been trained, trying to learn the simple 2-input XOR operation: ![xor operation][4] Input to a Tsetlin Machine is a list of Booleans (in this case, the list is length 2 because the goal is to emulate XOR, which takes 2 inputs). After the input is taken, it is duplicated and inverted. So, the complete input ends up taking the form `{{a, b}, {NOT a, NOT b}}`. For example, an input of `{True, False}` would produce `{{True, False}, {False, True}}`. Once the complete input is calculated, it is fed to a team of Tsetlin Automata (which are randomly initialized). There are a number of Tsetlin Automata equal to length of the input-- that is, each Automata corresponds to one input value. Based on its current state, each Automata chooses either to include or exclude the input (if the current state is less than or equal to the state identifier, the input is excluded. Otherwise, it is included). ![single clause calculate included][5] Any included inputs in the team are then ANDed together. There actually can be multiple teams of Tsetlin Automata, each of which chooses which inputs to include and exclude independently of the other teams (as well as ANDs the results independently). ![all clause final outputs][6] Once each team of Tsetlin Automata has calculated their final, joint result, the outputs from that result is sent to an output function. There are many different output functions, the two most common of which are OR and the Alternating Sum. For this example, I will use OR. ![output function][7] The final output from this Tsetlin Machine given the input of `{True, False}` is True, which happens to be correct. However, this machine will fail on an input of {False, True}, and will output, instead of the expected `True`, a `False`. So how does the Tsetlin Machine learn that this is wrong? Through feedback. There are 2 different kinds of feedback that a Tsetlin Machine can provide back to its' Automata: Type 1 and Type 2. Although the exact details of the types of feedback are rather complicated, the point of each is simple: Type 1 feedback combats false negative output (when the machine outputted a False when it should have outputted a True), and Type 2 feedback combats false positive output (when the machine outputted a True when it should have outputted a False). Feedback is given to a clause at a time, based on a function provided by the user (at least in my implementation) called a "feedback decider" which takes a series of arguments that contain information about the current state of the machine . Each kind of output function requires a different kind of feedback decider, to make sure the feedback is correctly assigned. At the automata level, feedback takes the form of a weighted reward or punishment (a reward or punishment that probabilistically happens), based on an s-value (which controls precision) specified by the person training the machine. There is more information in the original paper and in my implementation about how feedback works. In short, feedback punishes or rewards automata to make them more likely to include or exclude inputs correctly. After feedback is given, then a new input is given to the machine and the process repeats. One detail that is important to note is that Tsetlin Machines can have multiple outputs, each of which is trained independently and has their own Tsetlin Automata teams. # Using the Framework The following chunk of code shows how one would train a Tsetlin Machine from scratch to learn the XOR operation using my framework: TsetlinMachineTrain[ (* function that trains a Tsetlin Machine *) TsetlinMachineInitialize[ (* make a new Tsetlin Machine *) 3, (* state identifier 3 *) 2, (* 2 inputs *) 2, (* 2 clauses *) {TsetlinUtilityOr}], (* one output that uses the function TsetlinUtilityOr *) {{False, False}, {False, True}, {True, False}, {True, True}}, (* training input data *) {{False}, {True}, {True}, {False}}, (* training output data *) {{False, False}, {False, True}, {True, False}, {True, True}}, (* testing input data *) {{False}, {True}, {True}, {False}}, (* testing output data *) 9, (* s-value (precision) *) TsetlinUtilityOrFeedbackDecider[#1, #2, #3, #4, #5, #6, 2] &, (* feedback decider with threshold set to 2, more info in paper *) 1.00] (* train until it has 100% accuracy *) # Further Resources * https://github.com/ComradeSparklePony/WL-Tsetlin-Machine (my Wolfram Language implementation of a Tsetlin Machine) * https://arxiv.org/pdf/1804.01508.pdf (the original paper) * https://github.com/cair/TsetlinMachine (the original implementation of a Tsetlin Machine) [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=fixed_deterministic_run_1.png&userId=1684084 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=stevelearnpath.png&userId=1684084 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Overall_Architecture.png&userId=1684084 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=xor.png&userId=1684084 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ta-choice.png&userId=1684084 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=clauseoutput.png&userId=1684084 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=outputoutput.png&userId=1684084 Dmitri Volkov 2019-07-12T01:39:04Z https://community.wolfram.com/groups/-/m/t/1135793 GOAL OF THE PROJECT =================== During Wolfram Summer School 2017, I set out to create an efficient quantum computing framework in Mathematica. Prior to this project, there were already several quantum computing packages for Mathematica, including [Quantum][1], [QuCalc][2], and [Quantum Computing with the Wolfram Language][3], the last of which was a product of WSS 2016. However, there was no existing package that was hassle-free, and provided a unified representation of the various types of quantum systems one might want to use in computations. I set out to allow users to simulate quantum circuit computations on all of these types of quantum states - which I will go into shortly. My main goal, however, was to make the circuit computations as fast - and scalable - as possible. The main difficulty that arises when simulating quantum systems on classical computers is that a quantum system with $~{O}(n)~$ quantum bits, or qubits, requires a representation consisting of $~O(2^n)~$ classical bits. From the start, I knew that my primary task would consist of designing an architecture for the framework that would facilitate these computations. Background ========== Before I get into the specifics of my implementation, I'm going to review some of the basics of quantum computing: Quantum States ---------- In classical computing, information is stored in bits, i.e. $~0~$'s and $~1~$'s. At any point in time, each bit is in one of these two states. Operations such as "AND", "NOT", and "Controlled-NOT" gates take bits as input, and output other bits. In quantum computing on the other hand, the fundamental unit is the *qubit*, or quantum bit. A qubit lives in a Hilbert space $~H = \mathbb{C}^2~$. Rather than take values in $\{0,1\}$, a qubit can take any complex-valued state $\begin{bmatrix} \alpha \\ \beta \end{bmatrix}$ that is normalized: $\|\alpha \|^2+ \|\beta \|^2 = 1$. Rewriting this as $\alpha \begin{bmatrix} 1 \\ 0 \end{bmatrix} + \beta \begin{bmatrix} 0 \\ 1 \end{bmatrix} $, we can view the qubit as a linear combination, or *superposition* of the two basis states $ \begin{bmatrix} 1 \\ 0 \end{bmatrix} $ and $ \begin{bmatrix} 0 \\ 1 \end{bmatrix} $, and subsequently treat these as our quantum analogs of $0$ and $1$ so that we can perform *quantum* computations. During computation, a qubit does not have to take on either of its basis states. Rather, it "collapses" into one of its eigenstates when it is measured at the end of a computation. A computation consists of any unitary operator acting on the state of the qubit. ---------- Things get more interesting when we consider a composite quantum state, made up of multiple qubits. A quantum state comprised of two qubits, $q_a$ and $q_b$, lives in $~ \mathbb{C}^4~$. In the computational basis, $ \begin{bmatrix} 1 \\ 0 \\ 0 \\ 0 \end{bmatrix} $ describes the state in which $q_a$ and $q_b$ are both 0, $ \begin{bmatrix} 0 \\ 1 \\ 0 \\ 0 \end{bmatrix} $ corresponds to $0$ for $q_a$ and $1$ for $q_b$, $ \begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix} $ to $1$ for $q_a$ and $0$ for $q_b$, and $q_b$, $ \begin{bmatrix} 0 \\ 0 \\ 0 \\ 1 \end{bmatrix} $ to $1$ for both qubits. ---------- Unlike in the classical case, in quantum physics it is often not possible to decompose the state of a composite system into separate states for each subsystem. For example, no matter the choice of $\alpha$, $\beta$, $\gamma$ and $\delta$, it is not possible to write $ \frac{1}{\sqrt{2}}\begin{bmatrix} 1 \\ 0 \\ 0 \\ 1 \end{bmatrix} = \begin{bmatrix} \alpha \\ \beta \end{bmatrix} \otimes \begin{bmatrix} \gamma \\ \delta \end{bmatrix}$. In such a scenario, the state is said to be *entangled*. ---------- We can make things even MORE interesting by adding in statistical uncertainty. So far, we have been discussing what are referred to as *pure* states. Even though we have allowed qubits to be in superposition states, we were always sure to be in *that* superposition. A *mixed* state is a statistical ensemble of pure states. For example, $q_a$ could have a $50\%$ chance of being in the state $\begin{bmatrix} 0 \\ 1 \end{bmatrix}$ and a $50\%$ chance of being in the state $\frac{1}{\sqrt{2}} \begin{bmatrix} 1 \\ 1 \end{bmatrix}$. ---------- Okay, just one more complication: remember how we began by drawing the analogy between bits and qubits? We can extend this analogy to general digit systems. A classical system that can be in one of the d states $\{0, 1, \dots, d-1\}$ is transformed into a *qudit*: a normalized complex-valued state in $~ \mathbb{C}^d~$, which takes on superpositions of its $d$ basis states. My framework treats pure unentangled and entangled states, mixed states, qubits and qudits on the same footing. Quantum Circuits ---------- As I mentioned above, a computation consists of any unitary operator acting on your quantum state. If you are performing computations on many qudits, as is often necessary for the design of complex circuits, these operations essentially become large matrix multiplications. For example, an operation performed on 4 qutrits (three level quantum systems), would involve multiplying your state vector by a matrix of size $3^4 \times 3^4$. One can imagine how quickly this scaling becomes a performance issue. Design ======= In my framework, the basic data structures are `QuantumObservable` and `QuantumState`. A QuantumObservable consists of a Hermitian matrix and a description. A QuantumState consists of a density matrix, represented as a sparse array, a lookup table that associates row and column indices with combined computational basis states of the system, and an ordered list of quantum objects that comprise the state. For example, `psi = CreateQuantumState["w2" -> {0.4, 0.8}, {"w1", "w3"} -> {{0, .1, .9}, {.2, .4, .3}}]` returns a QuantumState consisting of quantum objects "w1", "w2", and "w3". ![quantum state][4]. "w1" and "w2" are qubits, while "w3" is a qutrit. "w1" and "w3" are input as one 2-dimensional array because they are entangled, and cannot be represented independently. The state is automatically normalized. We can visualize the density matrix of the state using `QuantumPlot[psi]`.![quantumplot][5] We can query the state to see whether it is pure, mixed, or entangled (for pure states) with commands like `EntangledQuantumStateQ`. Note that we represent all states in terms of density matrices rather than state vectors so that the architecture is consistent for pure and mixed states. This does not impact performance because we are using sparse arrays. Quantum Operations ---------- In my framework, quantum operations are not hard-coded as matrices. Instead, they are defined by rules which, for a d-dimensional quantum state, will apply the d-dimensional version of the operation. In order to avoid matrix multiplications, two-qudit operations like "CNOT" and "SWAP" are implemented through array reshaping and manipulation rather than being explicitly constructed. Quantum Circuit ---------- One of the most important aspects of my project is *quantum compilation*. A quantum circuit can be created either by giving a list of quantum operations, or concatenating other circuits. The quantum circuit is left unevaluated until it acts on a quantum state, at which time it is simplified by a host of pattern-based algebraic identities. This compilation reduces the number of operations in the circuit, minimizing the number of full-blown matrix multiplications. Other Features ---------- I also implemented a function to get the Von Neumann entropy of a quantum state, a partial trace function to produce the quantum state formed by tracing out subsystems, and a measurement function which calculates the expectation value of an observable on any quantum state. SUMMARY OF WORK ========== This Quantum Computing framework enables the simulation of quantum circuits for qudits (generalized d-level quantum systems. Using sparse arrays and lookup tables, this package efficiently stores quantum states, maintaining a unified structure for pure, mixed, and entangled quantum states. The user can create an initial quantum state, and generate a quantum circuit - either out of individual gate operations or by concatenating other circuits. The crux of the framework is quantum circuit compilation: The circuit is not evaluated until it acts on an input quantum state, and using pattern matching I implement a variety of algebraic simplification rules to minimize the number of matrix multiplications. Future Work --------------- Obviously, there are a plethora of quantum computing features I would have liked to implement had I had more time. In the future, I hope to add functionality for combining quantum states, as well as incorporating a wider variety of multi-qudit operations. In addition, I would like to include functions for well-known quantum algorithms such as Deutsch's, Grover's, and Shor's algorithms so that the user can apply them directly to a quantum state. [1]: http://homepage.cem.itesm.mx/jose.luis.gomez/quantum/ [2]: http://library.wolfram.com/infocenter/MathSource/657/ [3]: http://community.wolfram.com/groups/-/m/t/897811 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-05at7.05.08PM.png&userId=1081680 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-05at7.14.06PM.png&userId=1081680 Jacob Marks 2017-07-05T19:08:56Z https://community.wolfram.com/groups/-/m/t/1087153 Dear community, I am the main author of an old Quantum Mechanics add-on for Mathematica. We are not updating it anymore because we are creating a totally new Quantum Mechanics package, it will be very likely called qmDirac. The old Quantum Mathematica was very difficult to update, because through the years I wrote a messy source code. Our new qmDirac package is in a very early stage of development, however it would be great for me if you or your students try to use it, and let me know your thoughts and suggestions, this is the link: [http://qmdirac.weebly.com/beta-testers.html][1] Please take into account that the old Quantum Mathematica and the new qmDirac are not compatible, you cannot copy-paste from one to the other, neither use one file with symbols from one with the other, it will not work. As I said, the new qmDirac is in a very early stage, I believe you might find it is slow, or perhaps even wrong, in some calculations; please let us know if that is the case, as well as suggestions for new commands of functionality that you would like to use. And, well, we do not have any real documentation yet, just very few examples, without any explanation, in this link: [http://qmdirac.weebly.com/examples.html][2] Anyway I hope our efforts can be of some help to your research and teaching work. Hope to hear from you or from your students soon in this forum. Jose Mexico [1]: http://qmdirac.weebly.com/beta-testers.html [2]: http://qmdirac.weebly.com/examples.html Jose Gomez 2017-05-08T20:14:25Z https://community.wolfram.com/groups/-/m/t/1078649 I want to use standard engineering notation, so I use Symbolize[] to define a symbol q'' (q double prime) for the heat flux (heat transfer rate per unit area) as a composite of the letter q and double prime (actually two aliased single quotes: [Esc]'[Esc] [Esc]'[Esc]). I also want to use subscripts to denote the heat flux at different locations, e.g., the heat flux through a liquid film is represented by \!\(\*SubsuperscriptBox[\(q\), \(film\), \(\[Prime]\[Prime]\)]\) My example code is appended below. The problem arises when I rerun the notebook using either Shift-Enter or Evaluate Notebook. The first time I run the code, I get the expected answer \!\(\*SubsuperscriptBox[\(q\), \(film\), \(\[Prime]\[Prime]\)]\))^2 If I run the code a second time, I get the same result again (as expected). A third time, same result. However, if I run the code a fourth time, Mathematica seems to ignore the Remove[], and I get the unexpected result: f[\!\(\*SubsuperscriptBox[\(q\), \(film\), \(\[Prime]\[Prime]\)]\)]=625 The problem disappears if I append Quit[] as the final statement. I'm running Mathematica 11.1.1.0. Questions: 1. Why does Mathematica ignore Remove[]. 2. Why does it wait until the fourth time through the code to do so? 3. Why is Quit[] required to get the correct behavior? I'm not completely sure if this is a problem with Notation, with Remove, or some interaction of the two. Thanks. Example code: Remove["Global`*"] Needs["Notation`"]; Symbolize[ ParsedBoxWrapper[ SuperscriptBox["q", "\[Prime]\[Prime]"]]]; Symbolize[ ParsedBoxWrapper[ SubsuperscriptBox["q", "_", "\[Prime]\[Prime]"]]]; f[\[Xi]_] := \[Xi]^2 f[ \!\(\*SubsuperscriptBox[\(q\), \(film\), \(\[Prime]\[Prime]\)]\)] \!\( \*SubsuperscriptBox[\(q\), \(film\), \(\[Prime]\[Prime]\)] = 25. \) Glenn Carlson 2017-05-01T12:14:52Z https://community.wolfram.com/groups/-/m/t/1818557 I can connect to an external MQTT broker with the MQTTLink` library. Here below an example using the Mosquito.org testing service: Get@"MQTTLink`" imAclientForExternal = CreateClient[]; ConnectClient[imAclientForExternal, "test.mosquitto.org:1883"]; TopicSubscribe[imAclientForExternal, "wolframTest", "MessageReceivedFunction" :> (Print[ ByteArrayToString[#3["Data"]]] &)]; TopicPublish[imAclientForExternal, "wolframTest" -> "my personal message"]; TopicUnsubscribe[imAclientForExternal, "wolframTest"] But since this is not a documented library, I was wondering if it is possible, and how, to do exactly the same with the Channel framework. Pedro Fonseca 2019-11-03T17:33:20Z https://community.wolfram.com/groups/-/m/t/1365397 In Germany, there is the association *Zwanzigeins* that wants to change the awkward German pronunciation of numbers into something more agreeable. For example, the current German pronunciation of 21 is "ein und zwanzig" which is opposite to more agreeable English "twenty one". Obviously most Germans get used to the current pronunciation but for education it appears to create a challenge for number sense. The board of this German association Zwanzigeins has decided to support my research towards creating an ISO standard for the pronunciation of numbers. See this link to their summary of this: "Initiative zur internationalen Normung der Zahlenaussprache" https://zwanzigeins.jetzt/infos/normung-der-aussprache PM 1. My *updated* Mathematica notebook for testing this pronunciation is in the attachment or at https://doi.org/10.5281/zenodo.1244008 When you are a German user of Mathematica, please check this out and run some tests with this notebook and package, because when you like the analysis and the power of expression by Mathematica, then you might play an important role in supporting all of this (e.g. by demonstrating the application to others). PM 2. An earlier message was: http://community.wolfram.com/groups/-/m/t/1341254 Thomas Colignatus 2018-06-28T14:31:35Z https://community.wolfram.com/groups/-/m/t/1666112 #Cross-Post [Here](https://b3m2a1.github.io/making-a-website-with-easyide.html) --- A common thing that people want to do one they have a nice bit of code is that they way to share it with the world. That was me ~2 years ago and so I went out, found a [nice static website builder](https://docs.getpelican.com/en/stable/) , wrote a notebook to Markdown generator that would handle all the most common cell types I used, and then figured out how to deploy this to the [Wolfram Cloud](https://www.wolframcloud.com/) . It worked nicely for a while, but after a bit I wanted more control over how the site was built, so I sat down, wrote a Markdown to XML parser, wrote a website generation framework, and worked up what eventually became [Ems](https://github.com/b3m2a1/Ems) , and used this to build a [Mathematica tutorial](https://mresources.github.io/tutorial/) from some stuff I wrote for some chemists I used to work with. These days few of my sites are on the Wolfram Cloud anymore, as it's slow, prone to losing CSS, the URLs look like a scam website, and so on and so forth. But I still use the site builder. All the time. For example, the [Mathematica paclet server](https://paclets.github.io/PacletServer/) I built to host Mathematica packages and make it possible install them in a single line is built with this site generator. And so when I built out EasyIDE one of the first things I wanted to do was integrate my [site builder](https://github.com/b3m2a1/Ems) (via Ems) into the thing. In fact, this blog post itself is being written with EasyIDE:  And now that I have this stuff built out, let's start to make a blog. # Getting Started ## Getting EasyIDE If you need to get EasyIDE you can get it off the [paclet server](https://paclets.github.io/PacletServer/easyide.html) . From there you can follow the video here to choose a stylesheet and get it set up: [](https://www.youtube.com/watch?v=TMHiN9Ov2fQ) ## Creating the Site Root This is probably the most involved part of the process—and don't worry it's really not very involved at all. What we do is first create a directory for our websites to save to, go to `Plugins ? Site Builder ? Initialize` and follow the dialog there. After we have a new site, we reassign our project directory to that of the site we want to build and then we're good to go. Here's a video for that: [](https://www.youtube.com/watch?v=P5-_-PhWqGs) # Creating Content ## Writing Content Content is divided into two types: pages and posts. Posts are articles, these will be managed and listed on the site index. Pages are more for site info and will not end up on the site index. There should already be a sample page and sample post. We can open up Post #1 using the file browser:  You can write pretty much whatever you want here and it will get saved to Markdown, which is the format used to build the site. To maximize similarity between the appearance of the post as written and the post as deployed, it makes sense to use mostly formats that can easily be exported to the web. That means using simple cell styles like `"Section"` , `"Subsection"` , `"Code"` , `"Text"` , `"Item"` , etc. and putting images in their own cells (here I'd recommend putting them in `"Text"` cells as otherwise the exporter thinks they're input). ## Making New Content To make a new post or new page you can use the entries under `Plugins ? Site Builder ? New` . These will open up a new page or post or whatnot that you can put whatever you want in. ## Content Metadata At the top of the content notebook you'll see a metadata section that looks something like this:  It's here where we set all the page- or post-specific parameters. You can see there's a space for the list of authors, list of tags, and list of categories. You can also choose the title for your article as well as its slug, which is the name that is generally given to the portion of the URL coming after the root. E.g. in [https://b3m2a1.github.io/making-docs-with-easyide.html](https://b3m2a1.github.io/making-docs-with-easyide.html) the slug is making-docs-with-easyide. This slug will generally be automatically constructed from the title, but if you want a different one you can have it. You can also customize higher-level things, like change how the Markdown is exported via the `"ExportOptions"` metadata tag. For example, if you want the Markdown to export to a different directory, you can do this like: "ExportOptions"->{"Directory"->".."} Which will export the files to the directory one up from the current notebook directory. You can also specify that you'd like all your code to export as copyable images as in the docs, what types of cells should be exported, whether to export math cells via MathJAX or not, whether to use HTML to format more complicated format types, whether to include invisible anchor HTML elements before each section for easy of jumping, what kind of indentation to use for code cells, etc. It's not worth discussing all the possible customizations right now, so if you want to know if a certain customization is supported or request new ones it is probably easiest to [ask that here](https://github.com/b3m2a1/Ems/issues) . # Building The Site Now that we have content, we can build our site. This is pretty easy to do generally via `Plugins ? Site Builder ? Build Site` . Here's an example of how this works: [](https://www.youtube.com/watch?v=4Z7lGg6bNbs) ## Build Options As you can see in the video, when you request a build there are a number of options you can toggle which will change how your site gets built (and how fast it builds). * If `Generate Content` is turned off, not pages or posts will be built. * If `Generate Aggregations` is off, no new tag/author/category pages will be built—as the site size grows this can sometimes yield huge savings. * If `Generate Index` is off, no index pages are built. * If `Generate Search` is off, no search page (using [tipue search](http://www.tipue.com/search/) ) will be built. * If `Use Cache` is off, the content cache that is stored to speed up builds will be ignored. Finally, the other three options seem self-explanatory, but if not let me know and I'll write up what they do. ## Site Metadata Every site has a file `SiteConfig.wl` that specifies a bunch of more serious options that get fed into the build process. Here's part of what that looks like:  The specific options that are here will differ according to the theme used for the website, but these are the standard ones for a regular blog-type website. ## Site Themes All sites have a theme that comes with them, which is basically just a pile of XML templates and CSS and JS and such that the extracted content from each page/post gets fed into. My themes work generally the same as pelican themes, so you can find some info on the layout [here](https://docs.getpelican.com/en/stable/themes.html) . The major difference is that my themes use the [```XMLTemplate```](https://reference.wolfram.com/language/ref/XMLTemplate.html) framework and so writing them is a bit more annoying that writing pelican themes would be. I've sunk a good amount of time and effort into make the [ themes I've already written](https://github.com/b3m2a1/Ems/tree/master/Resources/Themes) pretty full featured, though. Given that, if you want a site-specific theme, you just need to make a directory called `theme` in the site root, copy the content of one of my existing themes in and modify that. If you want to write a new theme from scratch, I can find the time to write a tutorial about how to do that, too. # Deploying The Site Finally we have a site that looks and feels how we want it to, so it's time to deploy. The way I would do this is: * Create a git repository in the current directory (via the menu) * Create an empty repository on GitHub  * Set the current repository remote to that of the GitHub repo * Change the `output` folder name to `docs` * Push to GitHub * Turn on GitHub sites for your repository  Here's an example of that in action: [](https://www.youtube.com/watch?v=L_r1yidV5F0?autoplay) # WLSites.GitHub.IO At this point, I don't have plans to radically revamp this, but one thing I could imagine being useful work be a centralized place for hosting Mathematica-generated websites (doesn't have to be made with EasyIDE/Ems). To make this easier I created a GitHub organization called WLSites where people can contribute sites if they want. All they'll need to do is [let me know here](https://github.com/wlsites/wlsites.github.io/issues) what they'd like their site to be called and provide a quick description for it. Once I have that I'll make a new repo for them, and give them complete access to that. Here's an example of the kind of thing that I'm looking for: > New Site: b3m2a1 > > <br> > A personal page for b3m2a1 The benefit of this is that many sites can be hosted under the same roof. I'll also make a nice index page that updates every time a new site is added so that people can find your site if they simply go to [wlsites.github.io](https://wlsites.github.io/) . In fact, if you want to add a site and want to host the repo yourself that's also fine by me. I'll just add your site and info to the repo and your site will appear on the index. b3m2a1 ​  2019-04-22T07:40:24Z https://community.wolfram.com/groups/-/m/t/311582 Hi, A new function to the package: PhasesOfTheMoon[{y,m,d}] Marcel. Marcel Pelletier 2014-08-04T03:52:12Z https://community.wolfram.com/groups/-/m/t/830659 Hi All, I find this ['MCMC' package][1] that can perform Markov Chain Monte Carlo simulations. However, I found this package doesn't use much of the built-in stochastic process functions. Also, due to my very limited knowledge of stochastic processes, I'd like to get better understanding of MCMC via a more Mathematica way. As such, I'm wondering if such MCMC simulation can be performed with higher-level built-in stochastic functions (e.g. `RandomFunction`, `HiddenMarkovProcess`)? Note: Cross-posted at [StackExchange][2]. [1]: https://github.com/joshburkart/mathematica-mcmc [2]: http://mathematica.stackexchange.com/questions/111224/how-to-implement-markov-chain-monte-carlo-with-built-in-functions?noredirect=1#comment301914_111224 Ting Sun 2016-03-27T23:36:50Z https://community.wolfram.com/groups/-/m/t/1742031 I will like some help completing this compilation . It runs fine in Visual Studio 2017 and the solution projet is available at Github [here][1] My Mathematic code has a problem identifying one of the header files php.c . I went to the documentation ut can not figure how to include the file here since not sure where is in the VS2017 directory. Here is the code in Mathematica Needs["CCompilerDriver`"] CCompilers[] hello = CreateExecutable[" // MC777Scattering.cpp : This file contains the 'main' function. \ Program execution begins and ends there. // /******************************************** * Original work from Biomedical Optics Series Steven L. Jacques, Scott A. Prahl * mc321.c , in ANSI Standard C programing language * * Monte Carlo simulation yielding spherical, cylindrical, and \ planar * responses to an isotropic point source in an infinite \ homogeneous * medium with no boundaries. This program is a minimal Monte \ Carlo * program scoring photon distributions in spherical, cylindrical, * and planar shells. * * by Steven L. Jacques based on prior collaborative work * with Lihong Wang, Scott Prahl, and Marleen Keijzer. * partially funded by the NIH (R29-HL45045, 1991-1997) and * the DOE (DE-FG05-91ER617226, DE-FG03-95ER61971, 1991-1999). * * A published report illustrates use of the program: * S. L. Jacques: \"Light distributions from point, line, and \ plane * sources for photochemical reactions and fluorescence in turbid * biological tissues,\" Photochem. Photobiol. 67:23-32, 1998. * * Trivial fixes to remove warnings SAP, 11/2017 * Theodore Info: * The problem with the code was the fopen function. This function \ is deprecated * and has been replace with the fopen_s function whose parameters \ are as follows * fopen_s(<pointer to a file stream e.g FILE* >, <filename>, \ <options e.g w, r>) * Modified by Abohweyere Oghenefejiro Theodore of Durham College \ Canada * Modified by Jose E. Calderon University of Puerto Rico for a \ solution in VS C++ 2017 **********/ #include <math.h> #include <stdio.h> #include \"pch.h\" #include <iostream> #define PI 3.1415926 #define LIGHTSPEED 2.997925E10 /* in vacuo speed of light [cm/s] */ #define ALIVE 1 /* if photon not yet terminated */ #define DEAD 0 /* if photon is to be terminated */ #define THRESHOLD 0.01 /* used in roulette */ #define CHANCE 0.1 /* used in roulette */ #define COS90D 1.0E-6 /* If cos(theta) <= COS90D, theta >= PI/2 - 1e-6 rad. */ #define ONE_MINUS_COSZERO 1.0E-12 /* If 1-cos(theta) <= ONE_MINUS_COSZERO, fabs(theta) <= 1e-6 rad. \ */ /* If 1+cos(theta) <= ONE_MINUS_COSZERO, fabs(PI-theta) <= 1e-6 \ rad. */ #define SIGN(x) ((x)>=0 ? 1:-1) #define InitRandomGen (double) RandomGen(0, 1, NULL) /* Initializes the seed for the random number generator. */ #define RandomNum (double) RandomGen(1, 0, NULL) /* Calls for a random number from the randum number generator. */ /* DECLARE FUNCTION */ double RandomGen(char Type, long Seed, long *Status); /* Random number generator */ int main() { /* Propagation parameters */ register double x, y, z; /* photon position */ register double ux, uy, uz; /* photon trajectory as cosines */ register double uxx, uyy, uzz; /* temporary values used during \ SPIN */ register double s; /* step sizes. s = -log(RND)/mus [cm] */ register double costheta; /* cos(theta) */ register double sintheta; /* sin(theta) */ register double cospsi; /* cos(psi) */ register double sinpsi; /* sin(psi) */ register double psi; /* azimuthal angle */ register double i_photon; /* current photon */ register double W; /* photon weight */ register double absorb; /* weighted deposited in a step due to \ absorption */ register short photon_status; /* flag = ALIVE=1 or DEAD=0 */ /* other variables */ register double Csph[1001]; /* spherical photon concentration \ CC[ir=0..100] */ register double Ccyl[1001]; /* cylindrical photon concentration \ CC[ir=0..100] */ register double Cpla[1001]; /* planar photon concentration \ CC[ir=0..100] */ register double Fsph; /* fluence in spherical shell */ register double Fcyl; /* fluence in cylindrical shell */ register double Fpla; /* fluence in planar shell */ register double mua; /* absorption coefficient [cm^-1] */ register double mus; /* scattering coefficient [cm^-1] */ register double g; /* anisotropy [-] */ register double albedo; /* albedo of tissue */ register double nt; /* tissue index of refraction */ register double Nphotons; /* number of photons in simulation */ register short NR; /* number of radial positions */ register double radial_size; /* maximum radial size */ register double r; /* radial position */ register double dr; /* radial bin size */ register short ir; /* index to radial position */ register double shellvolume; /* volume of shell at radial \ position r */ /* dummy variables */ register double rnd; /* assigned random value 0-1 */ register double temp; /* dummy variables */ FILE* target; /* point to output file */ /**** INPUT Input the optical properties Input the bin and array sizes Input the number of photons *****/ mua = 1.0; /* cm^-1 */ mus = 0.1; /* cm^-1 */ g = 0.090; nt = 1.33; Nphotons = 100000000; /* set number of photons in simulation */ radial_size = 6.0; /* cm, total range over which bins extend */ NR = 1000; /* set number of bins. */ /* IF NR IS ALTERED, THEN USER MUST ALSO ALTER THE ARRAY \ DECLARATION TO A SIZE = NR + 1. */ dr = radial_size / NR; /* cm */ albedo = mus / (mus + mua); /**** INITIALIZATIONS *****/ i_photon = 0; InitRandomGen; for (ir = 0; ir <= NR; ir++) { Csph[ir] = 0; Ccyl[ir] = 0; Cpla[ir] = 0; } /**** RUN Launch N photons, initializing each one before progation. *****/ do { /**** LAUNCH Initialize photon position and trajectory. Implements an isotropic point source. *****/ i_photon += 1; /* increment photon count */ W = 1.0; /* set photon weight to one */ photon_status = ALIVE; /* Launch an ALIVE photon */ x = 0; /* Set photon position to origin. */ y = 0; z = 0; /* Randomly set photon trajectory to yield an isotropic source. */ costheta = 2.0*RandomNum - 1.0; sintheta = sqrt(1.0 - costheta * costheta); /* sintheta is always \ positive */ psi = 2.0*PI*RandomNum; ux = sintheta * cos(psi); uy = sintheta * sin(psi); uz = costheta; /* HOP_DROP_SPIN_CHECK Propagate one photon until it dies as determined by ROULETTE. *******/ do { /**** HOP Take step to new position s = stepsize ux, uy, uz are cosines of current photon trajectory *****/ while ((rnd = RandomNum) <= 0.0); /* yields 0 < rnd <= 1 */ s = -log(rnd) / (mua + mus); /* Step size. Note: log() \ is base e */ x += s * ux; /* Update positions. */ y += s * uy; z += s * uz; /**** DROP Drop photon weight (W) into local bin. *****/ absorb = W * (1 - albedo); /* photon weight absorbed at \ this step */ W -= absorb; /* decrement WEIGHT by amount \ absorbed */ /* spherical */ r = sqrt(x*x + y * y + z * z); /* current spherical radial \ position */ ir = (short)(r / dr); /* ir = index to spatial bin */ if (ir >= NR) ir = NR; /* last bin is for overflow */ Csph[ir] += absorb; /* DROP absorbed weight into bin */ /* cylindrical */ r = sqrt(x*x + y * y); /* current cylindrical radial \ position */ ir = (short)(r / dr); /* ir = index to spatial bin */ if (ir >= NR) ir = NR; /* last bin is for overflow */ Ccyl[ir] += absorb; /* DROP absorbed weight into bin */ /* planar */ r = fabs(z); /* current planar radial position */ ir = (short)(r / dr); /* ir = index to spatial bin */ if (ir >= NR) ir = NR; /* last bin is for overflow */ Cpla[ir] += absorb; /* DROP absorbed weight into bin */ /**** SPIN Scatter photon into new trajectory defined by theta and psi. Theta is specified by cos(theta), which is determined based on the Henyey-Greenstein scattering function. Convert theta and psi into cosines ux, uy, uz. *****/ /* Sample for costheta */ rnd = RandomNum; if (g == 0.0) costheta = 2.0*rnd - 1.0; else { double temp = (1.0 - g * g) / (1.0 - g + 2 * g*rnd); costheta = (1.0 + g * g - temp * temp) / (2.0*g); } sintheta = sqrt(1.0 - costheta * costheta); /* sqrt() is faster \ than sin(). */ /* Sample psi. */ psi = 2.0*PI*RandomNum; cospsi = cos(psi); if (psi < PI) sinpsi = sqrt(1.0 - cospsi * cospsi); /* sqrt() is faster \ than sin(). */ else sinpsi = -sqrt(1.0 - cospsi * cospsi); /* New trajectory. */ if (1 - fabs(uz) <= ONE_MINUS_COSZERO) { /* close to \ perpendicular. */ uxx = sintheta * cospsi; uyy = sintheta * sinpsi; uzz = costheta * SIGN(uz); /* SIGN() is faster than division. \ */ } else { /* usually use this option */ temp = sqrt(1.0 - uz * uz); uxx = sintheta * (ux * uz * cospsi - uy * sinpsi) / temp + ux * \ costheta; uyy = sintheta * (uy * uz * cospsi + ux * sinpsi) / temp + uy * \ costheta; uzz = -sintheta * cospsi * temp + uz * costheta; } /* Update trajectory */ ux = uxx; uy = uyy; uz = uzz; /**** CHECK ROULETTE If photon weight below THRESHOLD, then terminate photon using \ Roulette technique. Photon has CHANCE probability of having its weight increased \ by factor of 1/CHANCE, and 1-CHANCE probability of terminating. *****/ if (W < THRESHOLD) { if (RandomNum <= CHANCE) W /= CHANCE; else photon_status = DEAD; } } /* end STEP_CHECK_HOP_SPIN */ while (photon_status == ALIVE); /* If photon dead, then launch new photon. */ } /* end RUN */ while (i_photon < Nphotons); /**** SAVE Convert data to relative fluence rate [cm^-2] and save to file \ called \"mcmin321.out\". Theodore: Here fopen(<filename>, <options>) has been replaced \ with fopen_s(<pointer to a file stream e.g FILE* >, <filename>, \ <options e.g w, r>) *****/ fopen_s(&target, \"mc321_.out\", \"w\"); /* print header */ fprintf(target, \"number of photons = %f\\n\", Nphotons); fprintf(target, \"bin size = %5.5f [cm] \\n\", dr); fprintf(target, \"last row is overflow. Ignore.\\n\"); /* print column titles */ fprintf(target, \"r [cm] \\t Fsph [1/cm2] \\t Fcyl [1/cm2] \\t \ Fpla [1/cm2]\n\"); /* print data: radial position, fluence rates for 3D, 2D, 1D \ geometries */ for (ir = 0; ir <= NR; ir++) { /* r = sqrt(1.0/3 - (ir+1) + (ir+1)*(ir+1))*dr; */ r = (ir + 0.5)*dr; shellvolume = 4.0*PI*r*r*dr; /* per spherical shell */ Fsph = Csph[ir] / Nphotons / shellvolume / mua; shellvolume = 2.0*PI*r*dr; /* per cm length of cylinder */ Fcyl = Ccyl[ir] / Nphotons / shellvolume / mua; shellvolume = dr; /* per cm2 area of plane */ Fpla = Cpla[ir] / Nphotons / shellvolume / mua; fprintf(target, \"%5.5f \\t %4.3e \\t %4.3e \\t %4.3e \\n\", r, \ Fsph, Fcyl, Fpla); } fclose(target); } /* end of main */ /* SUBROUTINES */ /************************************************************************** * RandomGen * A random number generator that generates uniformly * distributed random numbers between 0 and 1 inclusive. * The algorithm is based on: * W.H. Press, S.A. Teukolsky, W.T. Vetterling, and B.P. * Flannery, \"Numerical Recipes in C,\" Cambridge University * Press, 2nd edition, (1992). * and * D.E. Knuth, \"Seminumerical Algorithms,\" 2nd edition, vol. 2 * of \"The Art of Computer Programming\", Addison-Wesley, \ (1981). * * When Type is 0, sets Seed as the seed. Make sure \ 0<Seed<32000. * When Type is 1, returns a random number. * When Type is 2, gets the status of the generator. * When Type is 3, restores the status of the generator. * * The status of the generator is represented by Status[0..56]. * * Make sure you initialize the seed before you get random * numbers. ****/ #define MBIG 1000000000 #define MSEED 161803398 #define MZ 0 #define FAC 1.0E-9 double RandomGen(char Type, long Seed, long *Status) { static long i1, i2, ma[56]; /* ma[0] is not used. */ long mj, mk; short i, ii; if (Type == 0) { /* set seed. */ mj = MSEED - (Seed < 0 ? -Seed : Seed); mj %= MBIG; ma[55] = mj; mk = 1; for (i = 1; i <= 54; i++) { ii = (21 * i) % 55; ma[ii] = mk; mk = mj - mk; if (mk < MZ) mk += MBIG; mj = ma[ii]; } for (ii = 1; ii <= 4; ii++) for (i = 1; i <= 55; i++) { ma[i] -= ma[1 + (i + 30) % 55]; if (ma[i] < MZ) ma[i] += MBIG; } i1 = 0; i2 = 31; } else if (Type == 1) { /* get a number. */ if (++i1 == 56) i1 = 1; if (++i2 == 56) i2 = 1; mj = ma[i1] - ma[i2]; if (mj < MZ) mj += MBIG; ma[i1] = mj; return (mj * FAC); } else if (Type == 2) { /* get status. */ for (i = 0; i < 55; i++) Status[i] = ma[i + 1]; Status[55] = i1; Status[56] = i2; } else if (Type == 3) { /* restore status. */ for (i = 0; i < 55; i++) ma[i + 1] = Status[i]; i1 = Status[55]; i2 = Status[56]; } else puts(\"Wrong parameter to RandomGen().\"); return (0); } #undef MBIG #undef MSEED #undef MZ #undef FAC } ", "hellomyfirst", Language -> "C++", "Compiler" -> CCompilerDriver`VisualStudioCompiler`VisualStudioCompiler, "CompilerInstallation" -> "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community", "CompilerName" -> Automatic ] Import["!" <> QuoteFile[hello], "Text"] [1]: https://github.com/jecalderon/MC777Scattering Jose Calderon 2019-07-21T00:20:54Z https://community.wolfram.com/groups/-/m/t/1225366 Dr. Chung recently received a reward from Wolfram for his symbolic package. Does anyone know how to gain access? here is his book: [book][1] defunct link: http://symbcomp.gist.ac.kr/ defunct 2011 sample: http://library.wolfram.com/infocenter/Conferences/8063/ [1]: https://link.springer.com/chapter/10.1007/978-3-662-44199-2_4 Kay Herbert 2017-11-21T04:30:43Z https://community.wolfram.com/groups/-/m/t/851429 Are there any chemists here? I've got something for you: My [multiple bonds Demonstration][1] is now also available [as a package][2]. You can plot molecules from `ChemicalData[]` or from your own MOL files. The source only needs to contain information about the positions and multiplicity of the bonds, and of course about the positions and types of the atoms. Here are a few examples of the finished result (the package itself contains more notes about the technical aspects). Needs["multiBondPlot`"] Multicolumn[Labeled[multiBondPlot[#],#]&/@{"Benzene","Caffeine","Acetonitrile","TNT"},2] ![enter image description here][3] [1]: http://demonstrations.wolfram.com/DisplayingMoleculesWithMultipleBonds/ [2]: http://library.wolfram.com/infocenter/MathSource/9430/ [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=molecules.png&userId=69107 Bianca Eifert 2016-05-04T20:21:42Z https://community.wolfram.com/groups/-/m/t/1330671 This is a cross post of a blog post I wrote [here](https://www.wolframcloud.com/objects/b3m2a1/home/creating-a-mathematica-package-repository.html#main-content) --- This post is going to detail how I set up one of my recent projects—and a project I hope outlasts my direct involvement in it. We're going to talk about how to set up a custom paclet server in GitHub. ## Paclet Servers Revisited I talked about paclet servers a while back in [this post](building-a-mathematica-package-ecosystem-part-1.html) . Now we get to build on all of that work. Fundamentally, all we're going to be doing is building a paclet server via the method discussed there, but instead of deploying to the Wolfram Cloud, and opaque, unknown (and hence untrusted), [severely](http://community.wolfram.com/groups/-/m/t/1250045) [lacking](http://community.wolfram.com/groups/-/m/t/1250055) system we'll deploy to GitHub, the defacto standard for code sharing and highly open and trusted system. To do this, we'll mostly treat things as before, but it might be worth revisiting what we did before. ### Using the Paclet Manager We're going to hook in to Mathematica's built-in package manager, called the ```PacletManager``` . It's called that because Mathematica packages are distributed as ```.paclet``` files (which are just structured zip files with a ```Paclet``` expression cooked in). If people know the server where a paclet is stored, they can install it as easy as: PacletInstall[ "PacletName", "Site"->"http://paclet.site/Server" ] And so we're trying to make that accessible. ### Paclet Server Components To do that we need to expose a ```Paclets``` directory where all of our paclet files will be stored and a ```PacletSite.mz``` file that details the paclets that are stored there. Happily, I'd already built out the tool-chains for those previously, so I just had to adapt those to this project. The function that handles this is call ```PacletServerAdd``` . It takes a paclet and stores it in that ```Paclets``` directory and updates the ```PacletSite.mz``` file to reflect this ### Paclet Server Website The other part of a good paclet server is the interface that tells people what's on it. For my own stuff I built out a set of paclet server pages that detail what's available for download, the details of these, etc. As of the time I'm writing this for us this looks like:  Although the design is subject to change. What's important is that it details everything that's there and it's customizable for our needs moving forward. Each paclet has a page that is derived from the data in the ```PacletSite.mz``` file (which in turn reflects the data in the ```PacletInfo.m``` files cooked into each paclet). All we do here is take the parameters from the file, shove them into a notebook via some ```CellTags``` driven replacements, and then export that notebook to Markdown. From there the static site builder takes over. An example of one of those pages is:  Scrolling further down the page will give you all the details about who made it (me) what version it is, what extensions it has, etc. ## Building the Paclet Server We'll walk through most of the steps involved in this so that potentially others can make use of a similar flow. First we need to get everything working with GitHub. ### Making a GitHub Organization Since this is supposed to be a community effort I didn't want it attached to my personal GitHub. Better would be if it's associated with a [GitHub organization](https://blog.github.com/2010-06-29-introducing-organizations/) . So I made an organization that halirutan helpfully suggested I call [paclets](https://github.com/paclets) and made a [repository for hosting our server](https://github.com/paclets/PacletServer) .  ### Configuring the Repo To set up the repository I just cloned it locally, then started adding paclets to it via ```PacletServerAdd``` . The standard way I'd call it is PacletServerAdd["path/to/server", "PacletName"] Which adds the paclet for the folder and sets up things as they ought to be. Then I call PacletServerBuild["path/to/server"] Which builds out the website and all the necessary components. Finally I push this back to GitHub via an interface to its API (and also to git) that I wrote up. That generally looks like: Git["Add", "path/to/server", "All"->True]; Git["Commit", "path/to/server", "Message"->TemplateApply["Rebuilt on ``", DateString[]]]; GitHub["Push", "path/to/server"] And simple as that out server is built ### Making a ReviewQueue To make things nice for collaboration we'll want a way for people to submit things via GitHub on their own. The way we're currently doing this is via a review queue mechanism working off of GitHub's pull request machinery. A user forks the repo, adds a paclet to the ```ReviewQueue``` directory, and then we check to make sure it's formatted correctly before building it into the server. To simplify this I cooked up a [build script](https://github.com/paclets/PacletServer/blob/master/build/src/BuildScript.m) and [build notebook](https://github.com/paclets/PacletServer/blob/master/build/build.nb) . These load and submit the things in review queue (although checking that all the parts are there for the actual paclet is still best done by hand). I won't go into too much detail on the queue though, because I built an interface paclet to try to hide the all the steps in working with the queue. ### Protections in Place As with all packages, it's impossible to be sure that a paclet won't be harmful. To minimize the risk people face in using the server we added a [change log](https://paclets.github.io/PacletServer/pages/log.html) that extracts who committed and changed which paclets. If a user you don't trust has recently changed a paclet, don't install it. We even put this in bold face anywhere we provide installation code.  ## Building an Interface Paclet This has been the toughest part of the entire project. I wanted to make it so that people could submit their paclets directly in Mathematica, the fewer the lines of code necessary the better. To this effect I set up a paclet which is on the server and [you can install](https://paclets.github.io/PacletServer/publicpacletserver.html) to get the job done. The paclet is called (rather uncreatively) ```"PublicPacletServer"``` . I talked about it some [here](http://community.wolfram.com/groups/-/m/t/1330267) . To use it you install it based on what was on that link and load it like <<PublicPacletServer` It will expose a single function ```PublicPacletServer``` which provides access to the server and submission process. If you have a paclet you've been working on you can simply run: PublicPacletServer["SubmitPaclet", "YourPacletName"] And it will search for your paclet and submit it if it can find it and build it. If not you can also supply the path to your paclet and it will build and submit your paclet automatically. This submits the paclet to your review queue. To get it onto the public server you'll submit a request to merge your paclet in. The way you do that is via: PublicPacletServer["SubmitPullRequest"] And then once your paclet has passed review it will be added. This simple interface hides some complicated innards, though. ### Creating a Fork The heart of this workflow is forking the original server. This is a way that git knows which repository is the main / parent repository and makes it possible to easily merge changes up or down this tree. GitHub itself provides an [API for creating forks](https://developer.github.com/v3/repos/forks/) . I used this to make sure that no one has to download the entire server just to upload their package. What I do is I check whether you have a fork already by comparing your repositories to the forks of the main repository. You can check whether you have a fork by running PublicPacletServer["ForkedQ"] (*Out:*) True If you have a fork, ```"SubmitPaclet"``` will add it to the review queue for it. If not, it'll tell you to make a fork by running PublicPacletServer["Fork"] (*Out:*) "b3m2a1/PacletServer" ### Submitting a Paclet The paclet submission process hooks into GitHub's [API for single file uploads](https://developer.github.com/v3/repos/contents/) . It uses a toolchain I built for automatically finding and building a paclet (in fact the same one used by ```PacletServerAdd``` ) to build out a paclet then pushes it through the API to your fork's ```ReviewQueue``` directory. ### Submitting a Pull Request This is something I expected to be incredibly simple. There's a [pull request API](https://developer.github.com/v3/pulls/) that I do use in the end for submitting the request, but it turns out not all pull requests are valid. If there are changes on both the head and child repositories that conflict the child repository will need to merge the changes on the head repository before its changes can be pushed. To try to cover this case I run the [merges API](https://developer.github.com/v3/repos/merging/) on a [reference](https://developer.github.com/v3/git/refs/) extracted from the main repository. If that sounds like a whole bunch of jargon, that's because it is. Suffice it to say, for the most part you won't need this, but I tried to protect you if you do. ### Future Directions This paclet is most certainly in beta (it's currently only a ```0.0.1``` release). There are a number of features I still need to add, such as * Better support for cloning * Support for end users to build the server themselves * Review queue validation * A paclet submission GUI * Encapsulating functionality in a paclet If you'd like to help with any of these, feel free to [clone the repo](https://github.com/b3m2a1/mathematica-PublicPacletServer) and collaborate. In the meantime, I hope this encourages you to submit your paclets to the repository. We'd love to have them. b3m2a1 ​  2018-05-02T07:18:28Z https://community.wolfram.com/groups/-/m/t/1343859 This notebook and package of May 23 2018 includes the additive inverse too, while the original notebook and package of April 2 2018 only contained the multiplicative inverse. To avoid litter of different versions, I have updated at the April 2 2018 location, where the new notebook and package can be found under the old name. http://community.wolfram.com/groups/-/m/t/1313302 New summary: H = -1 is an universal constant. H represents a half turn along a circle, like complex number i represents a quarter turn. Kids know what it is to turn around and walk back along the same path. H creates the additive inverse with x + H x = 0 and the multiplicative inverse with x x^H = 1 for x != 0. Pronounce H as "ehta" or "symbolic negative one". The choice of H is well-considered: its shape reminds of -1 and even more (-1). Pierre van Hiele (1909-2010) already proposed to use y x^-1 and drop the fraction bar y / x with its needless complexity. Students must learn exponents anyway. The negative exponent might confuse pupils to think that they must subtract something, but the use of an algebraic symbol clinches the proposal. Also 5/2 can be written as 2 + 2^H, so that it is clearer where it is on the number line. This approach also causes a re-evaluation of the didactics of the negative numbers. The US Common Core has them only in Grade 6 which is remarkably late. The negative numbers arise from the positive axis x by rotating or alternatively mirroring into H x. Algebraic thinking starts with the rules that a + H a can be replaced by 0 and that H H can be replaced by 1. Subtraction a - b >= 0 may be extended into a - b < 0 with its present didactics, e.g. 2 - 5 = 2 - (2 + 3) = 2 - 2 - 3 = 0 - 3 = -3, but there is an intermediate stage with familiar addition 2 + 5 H = 2 + (2 + 3) H = 2 + 2 H + 3 H = 0 + 3 H = 3 H, that does not require (i) the switch at the brackets from plus to minus and (ii) the transformation of binary 0 - 3 to number -3. The expression a - (-b) involves (scalar) multiplication which indicates why pupils find this hard, and a + H H b is clearer. The use of H would affect the whole curriculum. There appears to be a remarkable incoherence in mathematics education and its research w.r.t. the negative numbers, which reminds of the problems that the world itself had since the discovery of direction by Albert Girard in 1629 and the introduction of the number line by John Wallis in 1673. This notebook provides a package to support the use of H in Mathematica. The notebook and package are intended for researchers, teachers and (Common Core) educators in mathematics education. Pupils in elementary school would work with pencil and paper of course. Thomas Colignatus 2018-05-23T10:14:17Z https://community.wolfram.com/groups/-/m/t/1072731 In a recent code I'm doing I needed to clear the OwnValue of a variable to assign a UpValue to it, thus I needed to clear the OwnValue, and only it, otherwise I would get nonsense. As far as I know, Mathematica doesn't seem to have a function with this capability. With bits and pieces from all over I could work-out these functions (hacks): SetAttributes[{ClearOwnValues, ClearDownValues, ClearUpValues, ClearSubValues}, HoldFirst] ClearOwnValues[var_Symbol] := (OwnValues@var = {};) ClearUpValues[var_Symbol] := (UpValues@var = {};) ClearDownValues[f_Symbol[args___]] := (DownValues@f = DeleteCases[DownValues@f, _?(!FreeQ[First@#, HoldPattern@f[args]] &)];) ClearUpValues[f_Symbol[args___]] := (UpValues@f = DeleteCases[UpValues@f, _?(!FreeQ[First@#, HoldPattern@f[args]] &)];) ClearSubValues[f_Symbol[args___][args2___]] := (SubValues@f = DeleteCases[SubValues@f, _?(!FreeQ[First@#, HoldPattern@f[args][args2]] &)];) Where the last three definitions are basically the same thing (I could probably make it less ugly, but...). A working example would be: Re@f[x_] ^:= x^2 f[w_][n_] := 1 f[x_] + g[x_] ^:= "Hey" f[z_] := Cos[z] f = 3; ShowValues := # -> #[f] & /@ {OwnValues, DownValues, UpValues, SubValues} // TableForm Where we have assigned all kind of "Values" to f and created a function to show it. ![Show][1] Where in each line of code we deleted a *Value. A example of real usage would be: SetAttributes[Test, HoldFirst] DefineReal[var_Symbol] /; ClearOwnValues@var := Im@var = 0 a = 1; DefineReal[a] a === 1 Which return False as expected. Other usage would be simply `ClearDownValues[Subscript[f, _]]`, since Mathematica can't Clear expressions like this, it prove to be extremely usefull. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Temp.png&userId=845022 Thales Fernandes 2017-04-26T02:35:16Z https://community.wolfram.com/groups/-/m/t/1166766 A friend of mine has shown to me this Facebook game, 8 ball pool. I particularly don't like playing games, and this pool game has a prediction-line for the balls (which I find it kind of a cheat, since real life pool there no guides). And I thought to myself it I could concoct some code to extend the prediction-line to improve aiming, just as a fun exercise (which in itself is more enjoyable to play the actual game). Image below shown the extend lines. ![enter image description here][1] And the code: This part is for positioning. I open the Facebook page in one screen while the other one has Mathematica. ![enter image description here][2] This part is basically cropping the screenshot, making it black-and-white, finding the cue ball and the prediction-line and overlaying it on top of the original image. ![enter image description here][3] This part dynamically takes screenshots and output the overlay image, which is the first image shown in this post. ![enter image description here][4] ## Disclaimer ## Although I don't find this type of thing cheating per se since you can achieve basically the same thing putting a ruler on your PC or phone. But I would advise against cheating on games only on the grounds that it makes the game less fun (that's why I put the code as images and I'm in no way responsible for your use of this code.). This post is only to show another side of Mathematica; with a few minutes of programming, it was possible to "cheat" in a game fairly easily (but buggy-ly). A better application of this would be to use an NN to play games, training an AI, etc (although the crude application of capturing the screen is a huge bottleneck...) [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture16.png&userId=845022 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2017-08-17_222251.png&userId=845022 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2017-08-17_222300.png&userId=845022 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2017-08-17_222313.png&userId=845022 Thales Fernandes 2017-08-18T01:39:54Z https://community.wolfram.com/groups/-/m/t/886243 Hello, I am trying to transfer the indicator bar to the user interface for my application but I fail to do so. I have 2 problems: 1. When I use ParallelDo loop the indicator bar is not get updated with the calculation. I tried to implant the idea from http://stackoverflow.com/questions/7352461/monitoring-progress-of-a-parallel-computation-in-mathematica , no success. 2. I would like to insert a row to my user interface where I can insert the indicator bar. I got the idea using Monitor and ProgressIndicator couple from -> http://stackoverflow.com/questions/4398214/update-a-progress-bar-in-mathematica Here, what I did so far. Main code Get[FileNameJoin[{NotebookDirectory[EvaluationNotebook[]], "DummyPackage.wl"}]]; Panel[DynamicModule[{np = 1000, nd = 30, Res = 1.0}, Column[{Style["Random", "Function"] , Row[{"Digits ", InputField[Dynamic[nd]]}, Spacer[5]], Row[{"Precision ", InputField[Dynamic[np]]}, Spacer[5]], Button[Style["Calculate", Green, Bold], Res = DummyPackage`myDummyF[nd, np], Method -> "Queued"], Row[{Style["Result ", 12, Red], InputField[Dynamic[Res], FieldSize -> 30, Enabled -> False]}, Spacer[15]] }], Initialization :> ( Get[FileNameJoin[{NotebookDirectory[EvaluationNotebook[]], "DummyPackage.wl"}]];)]] the package BeginPackage["DummyPackage`"] myDummyF[nd_,np_]:=Module[{mat,mat2,aI}, ns=200; mat=SetAccuracy[RandomReal[{-100,100},ns],nd]; mat2=SetAccuracy[RandomReal[{-200,200},ns],nd]; aI=ConstantArray[0,np]; SetSharedVariable[aI,iC]; Time=AbsoluteTiming[ If[nd<=16, Monitor[Do[ If[iC==2,Print["---------------------"]]; If[iC==2,Print["Do Loop"," nd= ",nd," np= ",np]]; aI[[iC]]=SetAccuracy[mat.(mat2/iC^0.5),nd],{iC,np}], ProgressIndicator[Dynamic[iC/np]]], Monitor[ParallelDo[ If[iC==2,Print["---------------------"]]; If[iC==2,Print[" ParallelDo Loop"," nd= ",nd," np= ",np]]; aI[[iC]]=SetAccuracy[mat.(mat2/iC^0.5),nd],{iC,np}],ProgressIndicator[Dynamic[iC/np]]]]]; Print["Do loop time = ",Time[[1]]]; aInum=Apply[Plus,(aI/np)]; Print["Total = ",aInum]; Print["---------------------"]; Return[aInum]] SetAttributes[{myDummyF},{ReadProtected,Protected,Locked}]; EndPackage[]; Here I can't see the bar in the nb. If I don't use a user interface for example : myDummyF[nd_, np_] := Module[{mat, mat2, aI}, ns = 200; mat = SetAccuracy[RandomReal[{-100, 100}, ns], nd]; mat2 = SetAccuracy[RandomReal[{-200, 200}, ns], nd]; aI = ConstantArray[0, np]; SetSharedVariable[aI, iC]; Time = AbsoluteTiming[ If[nd <= 16, Monitor[Do[ If[iC == 2, Print["Do Loop"]]; aI[[iC]] = SetAccuracy[mat.(mat2/iC^0.5), nd], {iC, np}], ProgressIndicator[Dynamic[iC/np]]], Monitor[ParallelDo[ If[iC == 2, Print[" ParallelDo Loop"]]; aI[[iC]] = SetAccuracy[mat.(mat2/iC^0.5), nd], {iC, np}], ProgressIndicator[Dynamic[iC/np]]]]]; Print["Do loop time = ", Time[[1]], ", np = ", np, ", nd = ", nd]; aInum = Apply[Plus, (aI/np)]; Print["Total = ", aInum]; Return[aInum]]; np = 100000; nd = 15; myDummyF[nd, np]; Do Loop version is working but I am not able to make it work for ParallelDo. Thank you. ps: I could not attach .wl format so I saved the package as .m file. Erdem Uguz 2016-07-11T16:46:13Z