This isn't a bad approximation, see [[https://www.google.com/search?q=y+-+y%5E3+%2F+6+%2B+y%5E5+%2F+120+-+y%5E7+%2F+5040+%2B+y%5E9+%2F+362880][Google’s answer]] for comparison.
So, yes, calc can do college-level math, even if the answers aren't perfectly
simplified. It's not Mathematica, but it is free and integrated into emacs, so
it's definitely nice to have.
** Date
Ever want to know how many seconds old David Hasselhoff is? calc can do many
things, but it doesn't know much about Hasselhoff, so first I do a query on
Google for [david hasselhoff]. I get a knowledge card on the right saying he was
born July 17, 1952. It doesn't give a time, so we'll just assume it was at
midnight.
#+BEGIN_EXAMPLE
M-x calc
t N (put the current time on the stack)
'<Jul 17, 1952> (press ' to enter algebraic mode, then you input the date).
- (subtract the two to get the number of days David has been alive)
24 (we're going to multiply by 24, the number of hours in a day)
60 (the number of minutes in an hour)
60 (the number of seconds in a minute)
*
*
*
Final result:
1: 1910255938.01
#+END_EXAMPLE
There you have it, he's... wait, how many seconds? That's really hard to read.
Back into calc!
#+BEGIN_EXAMPLE
d g (toggle digit grouping)
The final final result:
1: 1,910,255,938.01
#+END_EXAMPLE
Ah, that's a 1.9 billion seconds. Sweet!
** Financial.org
I recently chatted with emacspeak creator T.V. Raman, and told him I was
writing a series of short tutorials about calc. He is really a calc fanatic, and
told me a story in which he astounded a loan officer by calculating scheduled
loan payments with just a few keystrokes in calc. Raman is living proof that
calc is a useful tool for so many situations, and it always pays to have emacs
running. He also mentioned that he found the explanation in the calc tutorial
about the financial functions to be the clearest he's ever read.
So, yes, calc can do finance. Let's say that you were sitting in front of a loan
officer, and she told you that for your loan of $500,000, you need to pay in 30
installments with a 5% interest rate. How much do you need to pay each month?
Wait a second! Stop right there, loan officer! I have calc!
#+BEGIN_EXAMPLE
M-x calc
500000 (the amount of the loan)
30 (the number of payments)
'5% (equivalent to typing 0.05)
b M (calc-fin-pmt, computing the amount of periodic payments to amortize a loan)
Result:
1: 25,000
#+END_EXAMPLE
OK, but that's a bit obvious, since $25,000 is just 5% of $500,000. If the
number of payments was much smaller, we'd get a larger value. Let's take another
question: if you wanted to only pay $10,000 in each installment? How many
installments would it take to pay off the loan?
#+BEGIN_EXAMPLE
'5%
10000 (the payment we want to make)
500000 (the loan amount)
b # (calc-fin-nper, calculate the number of installments needed)
Result
1: nper(0.05, 10,000, 500,000)
#+END_EXAMPLE
What? Oh, I see, I also go the message: "Payment too small to cover interest
rate: 10000". Oh, right, 5% of $500,000 is already $25,000, so we'd never pay it
off at that rate. What if we payed $50,000 instead?
#+BEGIN_EXAMPLE
'5%
50000 (the payment we want to make)
500000 (the loan amount)
b #
Result:
1: 14.2066908
#+END_EXAMPLE
So, it would take just over 14 payments to pay off the loan.
OK, one more cool one: Let's say you meet an investment banker who gives you the
following deal. I've got a investment for you, she says. Just give me $100,000
and I'll give you $10,000 at the end of each year for the next 12 years.
Assuming the interest rate will stay at 3% for the next 12 years. Is it a good
deal?
Hey, what are you asking me for? I have no idea! Calc knows, though, because it
can tell you the break-even point for the cost of an investment that gives
periodic payments.
#+BEGIN_EXAMPLE
'3% (the interest rate)
12 (the number of payments)
10000 (the payment you get each time)
b P (calc-fin-pv, calculate the "present value" of the investment, the break-even point for the investment)
Result:
1: 99,540.0399357
#+END_EXAMPLE
In other words, the break-even point for the initial cost is $99,540. If the
investment costs more than this, it's no good at that assumed interest rate.
Better reject the deal. Trust calc more than any investment banker.
This is just a small sampling of some of the financial calculations that calc
can perform. The next time you are making an investment, fire up calc. You'll
not only have confidence in the deal, you may just amaze someone with the power
of emacs, just like T.V. Raman did.
** Fractional Arithmetic
This one is pretty short, but it's about one of my favorite features of calc:
the ability to handle fractions as fractions instead of rendering them as real
numbers.
Quick, what's =5/8 + 9/21=?
Um, ok... better start multiplying things... wait, let's just tell calc to do
it.
#+BEGIN_EXAMPLE
M-x calc
5:8 (this is how you enter a fraction)
9:21
+
Result:
1: 59/56
#+END_EXAMPLE
So easy! If we want to convert it to a float you can do this:
#+BEGIN_EXAMPLE
c f (convert to
float)
Result:
1: 1.05357142857*10.^0
#+END_EXAMPLE
And if you want it back as a fraction, then just do:
#+BEGIN_EXAMPLE
c F (convert to fraction)
Result:
1: 59/56
#+END_EXAMPLE
That's so awesome!
You could also enter fractions this way:
#+BEGIN_EXAMPLE
m f (set fraction mode, integer division will result in fractions)
5
8
/
Result:
1: 5/8
#+END_EXAMPLE
Now you can live in the nice world of fractions as much as you like. It's a nice
world, full of pleasant to look at integers taking up little horizontal space
** HEX
OK, seems like there's interest in some quick calc tips. Here's today's:
How to convert decimal to hexidecimal. Let's say you want to convert number
12345 to hex.
#+BEGIN_EXAMPLE
M-x calc
d 6 (sets the number radix to 16, meaning all output will be in hex)
10#12345 (inputs the number 12345 in base 10)
The output reads:
1: 16#3039
#+END_EXAMPLE
The answer is therefore =0x3039=.
And then you can do a =d 0= to set the number radix back to normal, base 10.
Here's how to do the other way. Let's convert =0xABCDEF= to base 10.
#+BEGIN_EXAMPLE
M-x calc
16#ABCDEF
The output reads:
1: 11259375
#+END_EXAMPLE
** More on Algebra
Jim is 42 years old. He has one brother, and their total age is 100. What is the
brother's age? OK, this isn't a very hard problem, but let's just introduce calc
algebra by solving it.
#+BEGIN_EXAMPLE
M-x calc
'42 + x = 100 (' to enter algebraic input)
a S x (solve for x)
Result:
1: x = 58
#+END_EXAMPLE
Let's make this harder. Jim and Dan's ages sum to 100. Jim is 5 years older than
Dan. How old are they?
#+BEGIN_EXAMPLE
'[j + d = 100, d + 5 = j]
a S j,d
Result:
1: [j = 52.5, d = 47.5]
#+END_EXAMPLE
Nice!
And of course it can give you more than just numerical solutions:
#+BEGIN_EXAMPLE
'sin(x) + tan(y) = pi / 2
a S y (solve for y)
Result:
1: y = arctan(pi / 2 - sin(x))
#+END_EXAMPLE
Sometimes there are more than one solution. For example:
#+BEGIN_EXAMPLE
'x^2 = 25
a S x
Result:
1: x = 5
#+END_EXAMPLE
Wait, what happened to -5! That's a valid solution, why didn't calc tell us
about it? What's happening here is that calc is telling us about the first valid
thing it can find, which is basically how it operates. But you can always get
everything:
#+BEGIN_EXAMPLE
'x^2 = 25
a P x (find the polynomial solutions)
Result:
1: [5, -5]
#+END_EXAMPLE
Sometimes there aren't a finite number of results because you aren't dealing
with polynomials. You can just get a generalized solution:
#+BEGIN_EXAMPLE
'sin(x)^2 = 25
H a S x (solve for x, giving the generalized solution)
Result:
1: x = arcsin(5 s1) (-1)^n1 + 180 n1
#+END_EXAMPLE
This uses the calc notation =n1=, which you just means any integer. You can also
see another notation =s1= which means any sign. In this case =5 s1= means that that
number can be 5 or -5.
Looking at how awesome calc is, it's just a shame I never knew about it in high
school...
** Pi and Precision
This one's about p and P and mostly about pi.
First, let's pi it up:
#+BEGIN_EXAMPLE
M-x calc
P (this gives you pi)
Result:
1: 3.14159265359
#+END_EXAMPLE
Well, I guess that's a reasonable pi. But, c'mon, this is calc. Can't we get a
bit more digits? How about 100?
#+BEGIN_EXAMPLE
p 100 (sets precisions to 100)
P (need to ask calc again for pi, it doesn't recalculate)
A random collection of notes from [[https://irreal.org/blog][Irreal's Blog]].
** Insert URL from Safari :IRREAL:NOTE:
:PROPERTIES:
:CREATED: [2018-08-04 Sat 17:44]
:END:
:LOGBOOK:
CLOCK: [2018-08-04 Sat 17:44]--[2018-08-04 Sat 17:45] => 0:01
:END:
Responding to [[http://irreal.org/blog/?p=6924][yesterday's post]], Sacha asks if I could post the code for
=jcs-insert-url= for others to use. I thought I'd already done that but
apparently not. That's probably because except for the part identical to
=jcs-get-link=, which I /did/ [[http://irreal.org/blog/?p=2895][write about]], it's pretty trivial. In any event,
here it is:
#+BEGIN_SRC emacs-lisp
(defun jcs-insert-url ()
"Insert URL of current browser page into Emacs buffer."
(interactive)
(insert (jcs-retrieve-url)))
#+END_SRC
The =jcs-retrieve-url= function does all the work, of course, and is
just the code that I abstracted out of =jcs-get-link= to actually
retrieve the URL from Safari:
#+BEGIN_SRC emacs-lisp
(defun jcs-retrieve-url ()
"Retrieve the URL of the current Safari page as a string."
(org-trim (shell-command-to-string
"osascript -e 'tell application \"Safari\" to return URL of document 1'")))
#+END_SRC
One obvious problem with all this is that it works only for macOS. Not to
despair, though, because in the comments to the original post, [[http://irreal.org/blog/?p=6924#comment-3732979999][Brad Collins
suggests a solution]] that uses [[https://github.com/xuchunyang/grab-x-link][grab-x-link]] to do the same thing for FireFox and
Chrome on other systems. Be sure to read Brad's comment because there is---or at
least was---an issue with the MELPA version.
Finally, Sacha took the part about looking for ways to make your workflow easier
seriously and came up with a bit of Elisp to [[http://sachachua.com/blog/2018/01/org-mode-inserting-a-function-definition/][insert a function definition at the
point]], regardless of where it's defined. That's very handy and I immediately
stole her code and used it to insert the two functions above. My old method was
to switch to =init.el=, find the function, copy it to the kill ring, switch back
to the original buffer, add the source block fences, and insert the code between
them. Sacha's code did all of that for me and I didn't even have to leave my
current buffer. That's splendid. If you find yourself having to add function
definitions to your text, be sure to read Sacha's post. It will save you a lot
of time.
[[http://irreal.org/blog/?p=6926][Link]]
** Calc for Programmers :IRREAL:NOTE:
:PROPERTIES:
:CREATED: [2018-08-05 Sun 10:04]
:END:
:LOGBOOK:
CLOCK: [2018-08-05 Sun 10:04]--[2018-08-05 Sun 10:05] => 0:01
:END:
After writing about Florian Adamsky's post on [[http://irreal.org/blog/?p=7040][acronyms in AUCTeX]], I snooped
around on his site and came across a [[https://florian.adamsky.it/2016/03/31/emacs-calc-for-programmers-and-cs.html][nice post]] on [[https://www.gnu.org/software/emacs/manual/html_node/calc/index.html][Emacs Calc]] from a programmer's
and computer scientist's point of view. As regular readers know, I've been
working to increase my calc-fu lately so I read the post with interest.
Adamsky demonstrates some of the Calc functions that are useful to programmers
and computer scientists. This includes such things as entering and displaying
numbers in various radixes and performing the standard logical operations on
(the usually binary representation of) numbers. He even shows how to add a new
“units” representation to Calc---in this case bits/bytes/bits per second.
Calc is a large subsystem and famously hard to master but worth the effort. It's
been described as a “poor man's Mathematica.” It's not nearly as powerful as
Mathematica, of course, but it's surprising how many things it can do. If you're
a programmer/computer scientist and an Emacs user you should spend a little time
investigating Calc. It really can make your life easier. An easy way to get
started is to read Adamsky's post. It covers only a small slice of Calc but will
give you an idea of its power.
[[http://irreal.org/blog/?p=7044][Link]]
** Parsing with Org-Element :IRREAL:NOTE:
:PROPERTIES:
:CREATED: [2018-08-10 Fri 17:55]
:END:
The other day, I saw [[https://www.reddit.com/r/emacs/comments/89bxe0/org_mode_longterm_time_tracking_for_freelancers/][this query]] on the reddit Emacs subreddit. I already have
solutions for this type of problem but I'm always interested in the how people
use Org mode to record and report data so I followed the link that primitiveinds
provided for [[https://alexpeits.github.io/programming/2017/02/12/org-timesheets.html][his solution]] to generating time reports.
Even if, like me, you already have your time tracking and reporting needs under
control, primitiveinds' solution is worth looking at for its own sake. It works
by looking for CLOCK entries in an Org buffer and accumulating the relevant
information in the CLOCK line as well data about the associated task. That might
seem like it would require routine but tedious text manipulation but
primitiveinds leverages the org-element functionality to easily handle the task.
He starts by calling =org-element-parse-buffer= to generate a tree
representation of the Org buffer. Then he uses =org-element-map= to examine each
CLOCK element (and only CLOCK elements) to extract the necessary
information. It's a great technique that can easily be adapted for other parsing
of Org data. The code that primitiveinds presents is easy to follow and he
provides a nice explanation of what it's doing.
If you need to programmatically examine Org data for further processing, you
should take a look at primitiveinds' post. It's definitely worth a read.
Very few Emacs users---no matter how advanced---ever need to worry about the
specifics of the Elisp bytecode, or even, for that matter, that it
exists. Still, as guys like Chris Wellons [[http://nullprogram.com/blog/2014/01/04/][have shown]], it can sometimes be useful
to have a basic understanding of the bytecodes.
R Bernstein has put together a comprehensive, book-length [[http://rocky.github.io/elisp-bytecode.pdf][documentation on Elisp
bytecodes]]. After a short introduction, the documentation considers the bytecode
environment including the compiler, interpreter, and bytecode optimization. Then
there's a long section on the individual bytecode instructions.
Finally, there are sections on the changes in bytecodes between Emacs versions,
a table of opcodes, and a reference section. There's also a GitHub repository of
the [[https://github.com/rocky/elisp-bytecode][document source]].
As I said, you probably will never need this but if you do, you'll be /very/
glad to have Bernstein's documentation. It's another example of the vibrant
Emacs community.
[[http://irreal.org/blog/?p=7166][Link]]
** Formatting Tables :IRREAL:NOTE:
:PROPERTIES:
:CREATED: [2018-10-28 Sun 09:13]
:END:
If you're like me, you automatically think of the Org mode table editor (or
Orgtbl minor mode) when you think of tables in Emacs. It's hard to beat that
functionality and Orgtbl mode makes it available everywhere in Emacs, even if
you're not in an Org buffer. Sometimes, though, you'd like to have special
formatting for some or all of the table. That's where =delim-col= comes in.
=Delim-col= is /built-in/ Emacs functionality that allows you to do things like
adjust what string separates the columns, add a beginning or ending string to
each item, add an ending string for each row, and adjust the padding in the
table. It can be really handy for copying and pasting and then reformatting
tables from an external source.
I didn't know about =delim-col= until I read about it [[https://emacsnotes.wordpress.com/2018/09/24/delim-col-a-handy-tool-for-creating-pretty-tables-and-converting-those-to-different-table-formats/][over at Emacs Notes]], where
you'll find a good explanation of the facility and what it can do. The Emacs
Notes post also offers at bit of Elisp to make choosing the strings and
delimiters a bit easier. By default you have to set them using a series of
=setq= statements if you want something different from the built-in choices. The
Emacs Notes codes arranges for you to be prompted for the values.
You probably won't need the =delim-col= functionality very often but when you do
it's much easier than using something like a keyboard macro. Take a look at the
post and see if you don't agree.
[[http://irreal.org/blog/?p=7540][Link]]
** Inserting a function definition :CHUA:NOTE:
:PROPERTIES:
:CREATED: [2018-08-04 Sat 17:40]
:END:
:LOGBOOK:
CLOCK: [2018-08-04 Sat 17:40]--[2018-08-04 Sat 17:42] => 0:02
:END:
While nudging jcs to add a definition of =jcs-insert-url= to the blog post about
[[http://irreal.org/blog/?p=6924][Making Things Easier]], I realized it might be handy to have a quick function for
inserting a function definition without thinking about where it's defined. This
tries to use the definition from the source, and it can fall back to using the
stored function definition if necessary. There's probably a better way to do
this, but this was small and fun to write. =)
Naturally, I used it to insert itself:
#+begin_src emacs-lisp
(defun my/org-insert-defun (function)
"Inserts an Org source block with the definition for FUNCTION."
(interactive (find-function-read))
(let* ((buffer-point (condition-case nil
(find-definition-noselect function nil)
(error nil)))
(new-buf (car buffer-point))
(new-point (cdr buffer-point))
definition)
(if buffer-point
(with-current-buffer new-buf ;; Try to get original definition
CLOCK: [2018-08-04 Sat 12:51]--[2018-08-04 Sat 12:54] => 0:03
:END:
Way back in 2014, I [[http://irreal.org/blog/?p=2575][posted]] about Eric Neilsen's excellent [[http://ehneilsen.net/notebook/orgExamples/org-examples.html][Emacs org-mode
examples and cookbook]]. I recently came across a reference to it and was reminded
what a great resource it is. It's easy to browse through and just read one or
two entries when you have time. In skimming through it, I learned---or perhaps
relearned---how to [[http://ehneilsen.net/notebook/orgExamples/org-examples.html#sec-10][insert in-line calculations in a document]].
As I wrote in the original post, Neilsen is a researcher and his cookbook is
oriented at using Org mode to produce documents of various types. Still, that
covers a lot of territory and there are many good examples of powerful Org mode
use cases in it. The Document has moved or, really, taken up a second
residence. It was originally hosted at [[http://fnal.gov/][Fermilab]], where Neilsen works, and it's
still there but it's also available at his own site. The two documents are
identical so it doesn't matter if you use the new link or the original one
pointing to FNAL.
If you're an Org user, especially if you use Org to produce documents,
you should take a look at Neilsen's cookbook and bookmark it for future
*TLDR*: I started using Emacs about 3 years ago. I couldn't be more grateful to
have seen the light, and to have been rescued from the darkness of Windoze,
Goggle and/or friends. After enlightenment, I've taken upon myself the task of
customising an environment to write my PhD thesis with Org Mode.*
*** Why
Post created in response to the [[https://www.reddit.com/r/emacs/comments/9ynsvc/write_a_thesis_using_emacs_and_orgmode/][current thread]] in /r/emacs/ on thesis writing
with Org Mode.\\ I see most people's reason to avoid Org mode for scientific
writing is the fact that supervisors or co-authors use Mic. Word. I'll try to
argue that that's not enough reason to accept subpar tools.
*** What I'll talk about
I'll mention a bit of my motivations, and then I'll discuss how to make use of
(mostly) built in Org functionality such as tagging, export, [[https://orgmode.org/manual/In_002dbuffer-settings.html][setupfiles]] and
includes, reference management, keyboard shortcuts and advanced searching; all
with the purpose of building a useful thesis writing environment. Readers should
have a minimum knowledge of Org mode, the Org export system and LaTeX.
*** My requirements
Here in the Netherlands, most PhD thesis consist of an introduction, 3 to 4
research chapters (as submitted for publication), a summary, bibliography and
appendices. What this means for me is that my writing environment has to
/necessarily/ satisfy the following *minimum requirements*:
- Inclusion of (parts of) external files
- Keeping track of references
- Include and reference figures
- Version control documents
- Support for sharing with my supervisor in whatever format he wants
Failure to comply with any of these means the editor is unfit for
purpose^{#fn.1”>1}. Unfortunately, this set of requirements are not seamlessly
satisfied by likes of Mic. Word or G. Docs. I reckon they can probably be
configured to satisfy them, but why bother.
Additionally, a PhD thesis writing environment should also provide the following
features:
- Extended searching facilities for both text and references
- Simple syntax for tables and equations
- Support within a proper text editor
- Shortcuts to reach my files and build the thesis
To the best of my knowledge, /only/ Emacs with Org Mode + ox-latex provide all
of these out of the box.
*** Moulding Org Mode for thesis writing
Most of my inspiration comes from reading Kitchin's blogs and code, and reading
the Org Mode documentation, mailing list and Emacs Stack Exchange. Here' I'll go
one by one through all of the requirements listed above, and how to deal with
them.
**** Prelude: File structure
I have a main /thesis.org/ document, with latex heading declarations and a
commented setup file. I also have /research.org/ files, in different
directories, with their own latex heading declarations and commented setup
files.
The first lines of /thesis.org/ look like the following:
'(("Open in Emacs" . org-ref-open-pdf-at-point-in-emacs))))
#+end_src
**** Include and reference figures
For each research project I keep a =./media= directory, where all my figures
live. You can include figures in Org mode by using the following syntax:
#+begin_src org
#+NAME: figurename
#+CAPTION: This is a figure caption
[[path_to_figure][link_description]]
#+end_src
Currently there is a bug in the ELPA version of Org mode, such that relative
paths to figures in =#+INCLUDE= 'd files aren't adapted with respect to the
including file, so the latex export cannot find them. I've [[https://code.orgmode.org/bzg/org-mode/commit/d81a1d088c74e605c99e90a2835c55df5144f43e][submitted a fix]]
which should land in the next release of Org.
**** Version control documents
[[https://magit.vc/][Magit]]. I thought about having the research chapters as git submodules in a
thesis git project directory, but I currently don't. This would allow me to
always have the thesis code in a saved state, even if I further work on my
research chapters to answer to reviewers questions.
**** Support for sharing with my supervisor
Unfortunately, my supervisor likes to write comments in Mic. Word. I give in
that sharing your writing with colleagues is a fundamental part of
research.\\ Fortunately, [[https://github.com/jkitchin/scimax/blob/master/ox-word.el][ox-word]] export via Pandoc & LaTeX is capable of
creating nice looking, structured Word files which I send to my supervisor. I
then manually work through each comment step by step, though I'm looking for a
way to improve this part of my workflow. I think the Emacs community is missing
a minor mode to track Word document changes from within Org Mode. There are some
ideas laying around on how to implement it [[https://lists.gnu.org/archive/html/emacs-orgmode/2015-06/msg00246.html][hidden deep in the mailing list]], or
in [[https://emacs.stackexchange.com/questions/34923/merging-changes-to-from-docx-files-into-org-files][this Emacs Exchange thread]].
I may update this post with more information later.
**** Extended search facilities
By extended search facilities I mean the ability to quickly search for
information in references, and to keep notes linked to the literature. For
searching I make use of [[https://github.com/jkitchin/org-ref/issues/597][org-ref + pdfgrep]], as shown in my org-ref setup. For
notes linked to documents I've recently started to use [[https://github.com/weirdNox/org-noter][Org-noter.]]
**** Simple syntax for tables and equations
Org tables are a pleasure to work with. The following:
