MathWorks Blogs

I was honored to have worked with Cleve at Ardent Computer. He ran the benchmark and demo group squeezing performance out of thin air. Great mathematician and a wonderful human being. I never stopped learning when I was around him. thttps://blogs.mathworks.com/cleve/2013/11/25/the-ardent-titan-part-1/

Cleve Moler was one of the big names in numerical methods, and participated in creation of canonical FORTRAN libraries for solving linear equations, and matrix algorithms more generally. To teach this more conveniently to his students, he wrote the original version of MATrixLABoratory to allow interactive exploration of the library functions without having to compile FORTRAN code. The original version was about 2000 lines of code in FORTRAN. Engineering students loved it so much that he decided to make a company around this product. His buddy expanded and rewrote the interpreter in C, for a PC, and the rest is history: "In 1983 Jack Little suggested the creation of a commercial product based on MATLAB. I said I thought that was a good idea, but I didn't join him initially. The IBM PC had been introduced only two years earlier and was barely powerful enough to run something like MATLAB, but Little anticipated its evolution. He left his job, bought a Compaq PC clone at Sears, moved into the hills behind Stanford, and, with my encouragement, spent a year and a half creating a new and extended version of MATLAB written in C. A friend, Steve Bangert, joined the project and worked on the new MATLAB in his spare time." User guide for the original version of MATLAB: https://blogs.mathworks.com/cleve/2018/02/05/the-historic-matlab-users… The source code of the very early (1982?) FORTRAN version of MATLAB: https://github.com/johnsonjh/matlab The origins of the first PC…

That manual is great! I highly recommend reading through it for anyone interested in computing history - and anyone interested in how to communicate clearly in technical writing. Here's a fun report from someone who had the 205 as their first personal computer: https://blogs.mathworks.com/cleve/2017/10/09/my-first-computer-the-bur… I loved this story at the end: > Skip on Minus > One of the programs that I wrote during the summer at the University of Utah involved a loop that was exactly 20 instructions long. That meant the entire loop could be loaded into the high speed memory. It didn't even need the jump instruction from the end of the loop back to the beginning. It would just continue execution from the duplicate of the code in the next block on the drum. The trouble was there was no way to exit the loop. > I needed a "Skip on Minus" instruction. There was a "Skip on Plus", but no "Skip on Minus". The EE grad student who maintained the machine was a guy named Joe. I wish I could remember his last name. Anyway, I told him I needed a "Skip on Minus" instruction. He said, "I'll put one in". He disappeared behind the cabinets with circuit diagrams and a soldering iron. He called out, "the op code will be 51". > I wrote my program with a "51" instruction. It worked perfectly. And so the University of Utah had the only Burroughs 205 Datatron in the world with a "Skip on Minus" instruction.

Just to add: Credit is also due to Prof Christian Reinsch from Technical University of Munich (in addition to Golub and Kahan) for the invention of the practical algorithm for computing the SVD still in use today. https://blogs.mathworks.com/cleve/2022/10/23/christian-reinsch-roland-… https://people.inf.ethz.ch/gander/talks/Vortrag2022.pdf https://www.mathworks.com/company/technical-articles/professor-svd.htm… https://en.wikipedia.org/wiki/Christian_Reinsch

The Pythagorean addition algorithm is iterative and really quite simple. I'm glad I looked it up: https://blogs.mathworks.com/images/cleve/moler_morrison.pdf

I like little online tools like this! Suggestion: include some notes in the tool page itself on safe ints and references like https://blogs.mathworks.com/cleve/2017/05/08/half-precision-16-bit-flo…

This an interesting post on Complex Step Derivative by the original author of LINPACK and MATLAB's founder himself: https://blogs.mathworks.com/cleve/2013/10/14/complex-step-differentiat…

Another short introduction to floating point number with pictures giving a better intuition of their distribution among real numbers: https://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/

Yes, it's showing the oldest son of a early matlab's employee. https://blogs.mathworks.com/steve/2006/10/17/the-story-behind-the-matl…

> When I took a tour of the Oak Ridge Leadership Computing Facility a few years ago, Buddy Bland, who is Project Director, told me he could tell when he comes to the Lab in the morning if they are running the LINPACK benchmark by looking at how much steam is coming out of the cooling towers. https://blogs.mathworks.com/cleve/2013/06/24/the-linpack-benchmark/ Different programs consume dramatically different amounts of power.

Matlab (somewhat) recently ditched jet as the default colourmap in favour of Parula. https://blogs.mathworks.com/steve/2014/10/13/a-new-colormap-for-matlab… Since most folks (typically students) simply use the default this should help end the tyranny of jet. I do still like jet for on screen visualisation, the extra contrast can be useful.

I was referring to the cell mode, not notebooks. In Matlab you create a new cell by starting a line with two comment characters (%%), in the Jupyter extension you use #%%. You can then run the current cell with ctrl+enter, no need for selecting anything. https://blogs.mathworks.com/community/2008/01/07/ive-got-something-to-…

In a similar vein, MATLAB has: WHY SPY IMAGE (https://blogs.mathworks.com/steve/2006/10/17/the-story-behind-the-matl…

:) Personally I've never used any serious complex analysis in my job (I'm very grateful too, because I always struggled a bit with it). The closest thing I've seen, which I did run into recently, is the use of complex numbers to compute very accurate finite differences. It's one of those delightful tricks that is both elegant and useful: https://blogs.mathworks.com/cleve/2013/10/14/complex-step-differentiat… I've been working in golang, which fortunately has built-in complex128 types, so it's proved very helpful in a project!

I wonder who and why would use the feature? These matrices are slow. Many kernels used in practice are separable https://blogs.mathworks.com/steve/2006/11/28/separable-convolution-par… and therefore much faster to compute than a generic convolution matrix. Also the UI is hard to use. 25 edit boxes is a lot.

Cleve Moler is 78 (https://en.wikipedia.org/wiki/Cleve_Moler), he is popularly known as the co-founder of MathWorks, and co-author of numerical computing libraries such as LINPACK and EISPACK. He maintains a blog (https://blogs.mathworks.com/cleve/) and still programs in MATLAB from what I can tell. He talked about a bit of MATLAB history last year in Argonne Training Program on Extreme-Scale Computing (ATPESC) -- https://extremecomputingtraining.anl.gov/sessions/dinner-talk-evolutio…

There was a very good article explaining this using MATLAB, but I can't find it right now. This one is pretty close and explains the concepts of overflow, underflow, etc. The diagrams about "eps" are pretty good, even if your language of choice is Python, C/C++, etc. http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/

I think your gut feeling needs some serious recalibration. Please consider "the Hilbert matrix" (http://blogs.mathworks.com/cleve/2013/02/02/hilbert-matrices/) and more generally condition numbers (https://en.wikipedia.org/wiki/Condition_number), and in regards to "computationally efficient differential inversions based on small changes to the matrix", consider what happens to a polynomial's roots when you make small changes in the coefficients.

I'm well aware of how and when it works. It is the recognized idiom to perform in-place operations in practice in Matlab code [1]. It would be nice to take advantage of the same idea in mex code where possible. For example an API function that indicates if it is safe to over-write an input array and return it as the corresponding output or not. I don't think Mathworks currently provide documented and future-safe means to do so however. (If one controls all the code, updating things in-place is possible in practice if careful, using the A(1)=A(1); trick I gave in a parent post. Such code is just not guaranteed to be future-proof.) [1] http://blogs.mathworks.com/loren/2007/03/22/in-place-operations-on-dat…

Mostly nonsense. You are making the same mistake as Matlab, throwing away all the internal Intel precision, just because you don't know the boundaries and limitations or you don't care. In short Matlab did as you said in v6.0 and it was wrong. Read Kahan and matlab's (non)"defense": http://www.cs.berkeley.edu/~wkahan/MxMulEps.pdf http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/

Another article of the blog is about the modelisation of the Hyperloop vehicule (+environment): http://blogs.mathworks.com/seth/2013/11/07/hyperloop-model-architectur… It can be read as an introduction to Model Based Design. It shows for instance the interest of handling variants to test either different hardware concepts or different level of representativity.

FYI, they finally included a dataframe like data type in base MATLAB as well and called it `table`: http://blogs.mathworks.com/loren/2013/09/10/introduction-to-the-new-ma… So you don't need a stats license for that anymore. The question is how many functions will accept this datatype, which is one of the key problems with some of the more advanced datatypes (timeseries has similar issues).

I believe that's an example of 'logical indexing', which is a useful feature in many vector-oriented languages / packages: http://blogs.mathworks.com/steve/2008/01/28/logical-indexing/

The final MATLAB example of "Inplace modification" is not correct. function f(out, x) out = x.^2 end x = rand(10) y = zeros(length(x), 1) f(y, x) What happens here when you call f(y, x) is: 1. The arrays x and y are passed to f (no memory copying done yet, since MATLAB uses copy on write) 2. When we have `out = x.^2`, this will allocate a new array in memory and store in it the result of `x.^2`, and will call this `out`. The original `out` which was passed into the function can now be garbage collected (although it won't be, because it's still in the parent scope as 'y') 3. When the function exits, the new `out` goes out of scope and can be garbage collected. So all this example does is allocate a new array, assign x.^2 to it, and then throw that result away again. There's no in-place modification. You can't really pass a matrix by reference in MATLAB like you can in Python, however in some cases you can write your function in a specific way which will ensure in place operations are done and prevent a huge matrix copy. For example (pauses are just there so that you can watch task manager memory usage): function x = inPlace() x = rand(100000000, 1); pause(3); x = doSomething(x); pause(3) end function y = doSomething(y) y = y.^2; end Conditions required are: * Input and output variables must have same name in caller * Input and output variables must have same name in callee * Callee must be inside a function,…

The paper by Lyness and Moler is nice, but if it's really "about the idea in this post" then the fact is somewhat hidden. It's mostly about using the Cauchy integral formula to turn derivatives into integrals, using the Poisson summation formula to relate those to finite sums, and using the Moebius inversion formula to get those relations into a form from which you can extract the derivatives. Maybe taking a very short partial sum of one of the series in Theorem 2 gives you the result in the blog post here, but that seems rather sledgehammer-to-crack-a-nut-ish when (as the blog post says) all you need is the Cauchy-Riemann equations. I think it's true that the Lyness-Moler idea of "numerical differentiation by numerical complex integration" was, historically, part of the chain of ideas that led to the very simple "complex-step approximation" discussed in the blog post. But that's a far cry from saying that their paper is "about the idea in this post"! There's some discussion of the history here: http://blogs.mathworks.com/cleve/2013/10/14/complex-step-differentiati… where Moler (as in "Lyness and Moler") says "The complex step algorithm that I'm about to describe is much simpler than anything described in that 1967 paper. So, although we have some claim of precedence for the idea of using complex arithmetic on real functions, we certainly cannot claim to have invented today's algorithm." And yes, Chebfun is very nice.