b3m2a1

Nevermind, from spelunking it looks like you're calling into J.R.'s WebMO stuff and I know his implementation

@JasonB. what are you using for point group symmetry calculations? I'd be interested to see a reference implementation since I've written a few imps. myself and they were never as simple as I'd like

Per that, it's sufficient to add WindowTitle->... to make it not increment, e.g. CreateNotebook[WindowTitle -> "tmp", Visible -> False] won't increment the counter although it's probably good to track some kind of unique tmp counter too (maybe Module[{tmp}, CreateNotebook[WindowTitle -> ToString@tmp]])

@kirma some kind of function that makes them silently to copy-paste-modify-etc.? I've written a bunch of those and never really been careful to make sure it didn't increment the counter

@kirma I think there might actually be some degree of caching implemented by notebooks but I think things need to render once, my memory is a bit hazy on this but I thought I saw signs of caching a while ago

@andre314 I'm still not sure if that means anyone can apply or if it's only people who reside in one of the listed countries

@Anovice Could be a FE bug, or you might have something in your init.m or some paclet that runs on load, try running the suite of trick Context[r], DownValues[r], SubValues[r], System`Private`HasDelayedValueQ etc. to figure out where it's defined

@kirkus the problem is that I do very little evaluation, in general, much more writing with the occasional quick test so I needed something that would handle that too. It was simple to setup, though, and by using some FE tricks you can even set the delay for when the dynamic expression does the autosave. I just put it into my writing stylesheet so I don't lose anything I write

I think the best solution is to just attach a Dynamic task to my notebook that saves every 5 minutes or so. This is likely possible to do without even touching the kernel, so should be fast.

@Nasser the issue is that it's fundamentally not reproducible, if it were I'd have reported it by now and found a workaround. I use Mathematica for complicated derivations and write-ups mostly these days and so the crashes happen largely when copying or cutting expressions or text that have been heavily formatted to make the logic/geometry clearer. On reboot, assuming my work wasn't lost, the expressions can be manipulated without issue

@gdelfino Unfortunately this issue has persisted over multiple versions and machines for me and is almost certainly related to the front-end struggling to handle complicated copy/pastes, potentially because it failed to fully resolve the box structure of a heavily formatted set of cells. Fundamentally the issue is the fragility of the front-end, which you also see any time you play with complicated FE tricks which are as likely to crash the system as to work

I've had four crashes in the last few days just copying and pasting formatted expressions

For a program that crashes and takes down the entire system as often as Mathematica does it's wild that there's no silent in-the-background autosave tool to keep a temporary duplicate in some scratch directory so if the system goes down you can recover from the crash

@ChrisK I ran into someone who'd tried out your EcoEvo package the other month, didn't ask them what they thought about it, but figured you might be interested in the from-the-field report

@gdelfino HoldAll, try Table[x, Evaluate@Echo@{x, 10}]

You should already be able to convert plain old Mathematica functions to WASM to run via a lightweight JS layer and to be quite honest it'd be easy to support the most common subset of Mathematica graphics/animations to a JS version that builds off of something like Vue (@Kuba has already built tooling around this), but no sane person would try to build a general purpose tool since that's just asking for 1000 people to send them bug reports that they don't care enough about to fix

Nominally that's a use case for the LLVM compiler and WebAssembly, but I don't know what kind of simple support WASM has any for WebGL, on the other hand you also have stuff like this from 2011 that suggest one might be able to make LLVM act as an interface layer if WRI wanted to support web animations: llvm.org/devmtg/2011-11/Wilhelmy_Exporting3DScenes.pdf

@VitaliyKaurov pretty slick but I can't help but feel the energy would be better committed to making a proper Mathematica extension for Jupyter

@Kuba agreed, some day maybe it'll be useful but not until 12 or something is the de facto standard and the package dev tools are back ported, but tbh I'm out of this game by now

I've never found them useful for C++, TypeScript, or python development so I was never crying out for the Mathematica one not to suck

I mean I've developed 10k+ loc Mathematica packages in the past and that's never been an issue for me, but I also don't even bother to use a debugger when I use other IDEs. I've always been partial to print + exception raising to isolate issues since debuggers tend to add more overhead and complexity than they're worth in my experience

Something useful for people who still develop for Mathematica: youtube.com/…

@VitaliyKaurov That's also shown up here in the years since the free engine released but quite honestly I've never had the need to test one-and-done fragments of Mathematica code

@VitaliyKaurov Years ago this worked: sandbox.open.wolframcloud.com/app/view/… but they've since killed the sandbox cloud notebooks

Agreed that it makes sense, but I think the Mathematica front-end is missing the necessary CSS-like flex constructions although you might be able to get a pure FE solution with some box-size trickery...

@Kuba If you know the relative proportions Scaled works (e.g. Scaled[.9] and Scaled[.1]) but I'm not sure if there's a sense of "remaining" space in Mathematica's windowing system beyond something constructed via Dynamic

@user13892 some of the older guard had at WRI's conference but I think the majority of the current users old have not

@ydd indent with 4 spaces in a message without any other text, you can also use ctrl-K to auto-indent

Less an observation and more the fact that oeis.org/A130595 popped up in my research

The positive and negative binomials being inverses of each other seems entirely natural to me

@C.E. a thing I appreciate about the Mathematica choice is that the matrix of binomials Array[Binomial, {10, 10}, 0] has an inverse given by the negative binomials Array[Binomial[-#2-1, -#-1]&, {10, 10}, 0]

For most practical purposes if you know the domain expert, you can email someone at WRI and they'll respond 90% of the time, back in 2019 I got a lot of help with various FE optimizations from John Fultz + gave him a bunch of feedback on what power users might want to do with the system

@Nasser I'm inclined to disagree with Knuth there as I think Stephen's answer is more flexible and expression generation via strings is almost always a bad idea but the exchange is fun

@gdelfino kinda a shame that they gave grid Mathematica such a nonsense name

Now I need to go back and see if I can revive my old one somehow...

Has anyone else's gravatar changed? I just logged on today and I am shook

In my experience, these ML-based approaches allow you to get highly-accurate energies for systems with up to like 10 atoms in a matter of seconds as opposed to half an hour or more if you're using the methods they are based off of

There have also been a number of attempts to get GPU-accelerated algorithms for these kinds of calculations, but unfortunately the types of integrals people have to solve and the iterative nature of the algorithms don't provide easy solutions and so instead people are spending more effort on training ML-models to learn the expensive portions of the calculations in a semi-transferable manner, which could also be implemented in Mathematica to provide a relatively fast approach

For things like metal-containing compounds there are cleverly constructed core-shell potentials that allow you to keep your calculations from blowing up, but I am not an expert in those

The beauty of a lot of this is that chemistry is largely a local process and so in the majority of cases going much larger than that has diminishing returns in terms of what you can really learn and model, which is really why organic chemistry is so successful

If you have access to something with say 24 cores and maybe 70 Gb of ram (not really that huge honestly) you can get up to like 20 atoms using more accurate techniques

@kirma you pick your battles, but even my little laptop can do some DFT calculations on molecules with up to say 5-10 atoms from the first and second rows of the periodic table (and maybe a Cl or Br if I'm feeling wild) and from those there are any number of clever ways to model portions of the reactivity or get IR spectra for characterization

Obviously Mathematica will never have native ES to run stuff off of, but a standard set of hooks into e.g. psi4 would be an interesting driver (and is something I worked on a bit like 7 years ago)

@JasonB what's the state of quantum chemistry/electronic structure integration in Mathematica? I've been building out a library of nuclear quantum effect techniques over the few years but have always thought it would be nice to take at least some of that and bring it into Mathematica given how nicely the language can set up certain types of models

@andre314 as phrased the poster seems to just be complaining that there's no easy generalization rather than requesting a concrete solution

@IstvánZachar If it's possible it'd probably be set up in a similar way to configuring a remote kernel

@Nasser at that point we'll just declare ChatGPT-based questions off topic I figure, same as W|A. You can use W|A directly from Mathematica, but we still don't accept those

Now if you want an interactive control panel for real time work, that I would maybe do in Mathematica

Python has a smaller footprint, starts up quickly for cron jobs, has a permissive license, isn't going to try to authenticate against some server, etc.

I'd use Python probably to run the sensor if it's autonomous and then process the data in Mathematica