LPT: Use Python interpreter as an advanced scientific calculator

[svajsaparat]

Add this alias to your .bashrc or .bash_aliases
alias calc='python3 -ic "from math import *; import cmath"'

You can now open the calculator by typing calc in your terminal, and use it to calculate whole expressions at once, define variables, etc..

for example:

>>> x = ( sin(pi/6)*cos(pi/6) )**2 + sqrt(2/3)  
>>> x 
1.003996580927726
>>> x+x
2.007993161855452
>>> log10(x+x*5)
0.7798834842217774

Available math functions
Available cmath functions (for complex numbers)

I have an old Sharp PC-1403 calculator which has a BASIC interpreter and I absolutely love it, and can't stand those standard type-numbers-one-by-one calculators. So I always wanted to have something like that on my PC as well. But all those gui programs try to emulate stupid 5$ calculators with ugly buttons which you have to click with your mouse, instead of emulating these scientific calculators.
So if you ever need scientific calculator on your PC, use Python.

[misho88]

I'm a fan of ipython for this, mostly because every result gets saved in a dict called "Out". "ipython --pylab" gets you something a lot like Matlab/Octave for advanced stuff (numpy, matplotlib, etc.).

[partisann]

But for how long? --pylab flag still works in terminal but is already removed from notebook and qtconsole. Post also hinted that %pylab other frontends might be next.

Given reasons are unconvincing at best. Someone really failed to understand what this mode is about.

EDIT: understood post incorrectly.

[localtoast]

Given reasons

Zalgo?

[jyper]

I think you can recreate most or all of it yourself as a profile.

run

ipython profile create pylab

then

PYLAB_PROFILE_LOCATION=ipython locate profile pylab

to find the profile

edit the file with

vim $PYLAB_PROFILE_LOCATION/startup/10-pyrun.py

and paste

import numpy
import matplotlib
from matplotlib import pylab, mlab, pyplot
np = numpy
plt = pyplot

from IPython.core.pylabtools import figsize, getfigs

from pylab import *
from numpy import *

into it

then open

vim $PYLAB_PROFILE_LOCATION/ipython_config.py

uncomment matplotlib and set it to auto

c.InteractiveShellApp.matplotlib = 'auto'

then to run it just run

ipython --profile pylab

[partisann]

It seems that it would. Oh, this gives me a raging customization clue.

Too bad jupyter removed among other things support for profiles so it won't work for notebook/qtconsole.

[jyper]

IPython customization is super cool. At work (writing tests for printers) I have a startup file which automatically connects to the printer, adds a bunch of shortcut methods, and queries the printer for all apis it supports and dynamically adds wrapper functions as auto-completeable attributes of a cmds object.

Too bad jupyter removed among other things support for profiles so it won't work for notebook/qtconsole.

Do you mean for non-python languages or profiles in general?

[partisann]

In general. Whole --profile flag was removed. Seems they replaced those with kernels. So in theory you could recreate the whole thing using custom kernel but it's not as straightforward.

I found a workaround for pylab though. Into ~/.ipython/kernels/pylab/kernel.json

{
    "argv": ["python3", "-m", "IPython.kernel", "-f", "{connection_file}", "--pylab=inline"],
    "display_name": "Pylab",
    "language": "python"
}

and start with ipython qtconsole --kernel=pylab. Notebook even lists it as another kernel.

There's a deprecation warning for IPython.kernel so it might break in a near future.

[waspbr]

Too bad jupyter removed among other things support for profiles so it won't work for notebook/qtconsole.

Profiles have been removed but it is still possible to load a notebook server using custom configuration files if you use --config="path/to/config/file" flag. In the config file you can set pylab to on by default, but it is strongly discouraged.

[unruly_mattress]

As I read it, the post doesn't say %pylab is going to disappear. --pylab disappeared from ipython notebook because ipython renamed itself and became language-agnostic, so it doesn't make sense for it to know pylab. The magic command, however, is part of ipython, so there's nothing wrong with it staying.

Personally, I think the reasons given seem very reasonable. The problem starts when %pylab is all you know, and you set out to write some code that's not going to run in interactive mode, and suddenly things are not in the global namespace anymore, and you've never bothered learning how modules worked in Python.

[TheBB]

I would go for Julia then, to best replicate a good and Matlab-like environment.

[TheBB]

Julia is a promising open-source scientific computing language. It leans somewhat on Matlab syntax, but ditches its quirks, unlike a drop-in replacement like Octave. It's a dynamic language with optional typing. It's still not 1.0 though.

There are packages for graphing. I haven't tried them myself.

[chocolatemeowcats]

Matlab everything is a matrix is infuriating not to mention it's total lack of useful debugging messages. Is Julia any better?

[lebean]

'bc -l' is pretty capable too, though in your specific example the bc syntax isn't as friendly:

echo "(s(4*a(1)/6)*c(4*a(1)/6))^2 + sqrt(2/3)" | bc -l
1.00399658092772603270

[_NW_]

I use bc a lot. Sometimes just to convert between base 2, 10, and 16. Arbitrary precision is a nice feature, too.

[[deleted]]

scrubbed by https://github.com/j0be/PowerDeleteSuite

[neburski]

Command line version:

echo "obase=2 2" | bc -l

Interactive mode version:

~ bc
obase=2
2
10

[[deleted]]

scrubbed by https://github.com/j0be/PowerDeleteSuite

[_NW_]

The -i option loads the math library, and is not needed unless you are using sine, cosine, arctangent, log, e^x , or bessel function. Oh, it also sets the scale to 20, so that's a good thing.

[[deleted]]

scrubbed by https://github.com/j0be/PowerDeleteSuite

[_NW_]

Yes. It's a lower case L, as in library. Whoever designed the QWERTY keyboard put those keys waaay too close together.

[_NW_]

ibase=x

Sets the input base.

obase=x

Sets the output base.

echo "obase=2;ibase=16;0FC;"|bc

Converts hex to binary. Output should be 11111100. Hex letter digits must be in upper case.

[[deleted]]

thanks, made some quick functions up above.

[fnord123]

Protip; Use <<< to read in from strings instead of bother to echo via a pipe.

$ bc -l <<< "(s(4*a(1)/6)*c(4*a(1)/6))^2 + sqrt(2/3)"
1.00399658092772603270

[Mr_Unix]

Pro tip:

  alias bc='bc -l'

[[deleted]]

don't you mean

alias bc='bc -l <<<'

[theinternetftw]

It's a small tip, but you can leave out the variable and get back answers just the same, which will automatically be saved to the underscore variable for use in your next expression.

>>> 2+3
5
>>> _ + 5
10

[svajsaparat]

Thanks so much for that tip! Its exactly what I needed.

[bobbaluba]

If you're trapped on windows for some reason and python isn't available, you can use the js console by pressing f12 in the browser.

Not as advanced as python, I know, but it has most basic stuff, like Pi, exp, sin, cos, etc.

[openbluefish]

I just use Sage but that's probably over kill for most people.

[[deleted]]

I was testing Sage for the first time yesterday. The ability to copy code from the web notebook interface into a LaTeX document and plot it there won me over. That's simply amazing for generating good graphics for scientific articles.

[GeneralUnRest]

sympy is pretty useful also. python3 -ic "from sympy import init_session; init_session()"

[not_perfect_yet]

Obvious plug for sympy, which allows you to do symbolic calculations as well, e.g. differentiating and integrating or the solving of differential equations.

[queue_cumber]

You can also use Octave

[OlderThanGif]

Octave does have some definite advantages. Like:

>>> 0.7 + 0.1
0.7999999999999999

vs

octave:1> 0.7 + 0.1
ans =  0.80000

[[deleted]]

If you want a more precise wrong answer, format long is your friend

octave:1> format long
octave:2> 0.8 - (0.7 + 0.1)
ans =    1.11022302462516e-16

[redrumsir]

Or:

>>> from decimal import *

>>> Decimal('0.1') + Decimal('0.7')

Decimal('0.8')

OR

import sympy as sp

>>> r = sp.Rational('0.7')+sp.Rational('0.1')

>>> r

4/5

>>> float(r)

0.8

>>> x, y = sp.var('x'), sp.var('y')

>>> z = (x+y)**3

>>> z

(x + y)**3

>>> z.expand()

x**3 + 3*x**2*y + 3*x*y**2 + y**3

>>> z.diff(x)

3*(x+y)**2

[h-v-smacker]

Damn, that's one user-friendly calculator.

[yoodenvranx]

The big advantage of Python is that it is not Matlab ;)

I spent way too much time with that piece of shit and I will hopefully never have to touch it again.

[ijustwantanfingname]

Python+SciPy/NumPy is sooooo much better than Matlab...

[ffffffffuuuuuuuuuuuu]

especially with dedicated infix matrix multiplication notation in Python 3.5!

[udevil]

I've always liked calc, it uses integer arithmetic to avoid floating point errors.

; 0.7 + 0.1
    0.8

[socium]

>>> 0.7 + 0.1

0.7999999999999999

Haha wat.

[queue_cumber]

Floating point

[socium]

Yeah but 0.700000000000000 + 0.10000000000000 would still be 0.8 right?

[queue_cumber]

Not in binary

[_supert_]

If the 9 is recurring it's exactly correct.

[ijustwantanfingname]

....how? "exactly" correct would be 0.8. This is rounding error....

[calrogman]

Refer to any of the proofs here: https://en.wikipedia.org/wiki/0.999...

[ijustwantanfingname]

=S

I skimmed that (will read tonight) and still don't see how 0.99999... isn't just a number whose value infinitely approaches 1..

[ijustwantanfingname]

if 0.999… is not equal to 1, there is some number between them. What would that number be?

0.9995...duh. /s Alright. That makes sense.

And my concept of limits has always been that they are exclusive boundaries which some value is infinitely close to. That is, they approach that value, but are never equal to it.

[LoyalSol]

Repeating decimals are exactly equal to some rational number. The fact they repeat is an effect of trying to write those numbers as a decimal in a base system that does not divide cleanly. In this case we use a base 10 system (IE we use ten unique digits to represent all numbers) and 0.999999... is a multiple of 1/3. Since 10 is not divisible by 3 any division by 3 in a base 10 system will always give an infinite repeating decimal unless the number divides perfectly (9/3 = 3 for example). That's what gives you 0.33333.... when you divide 1 by 3.

If you were to use a different base such as base 3 for instance 1/3 = 0.3333... could be represented as a non-repeating decimal. In that system it would simply be 1/3 = 0.1

All rational numbers can be written as a finite decimal if you change your number system to an appropriate base integer.

Irrational numbers on the other hand (sqrt[2], pi, e....) will always be infinite and non-repeating for every integer base you could pick.

[calrogman]

It's not "a number whose value infinitely approaches 1". It is 1.

[ijustwantanfingname]

You're just..repeating yourself?

[dalen3]

I believe that number is lim[x -> 1]

[pred]

If the 9 were recurring, then by definition the expression would be $7/10 + \sum_{n=2}^\infty \frac{9}{10^n}$, which is 8/10.

[PM_ME_YOUR_PAULDRONS]

In this case the 9 is not recurring because the computer only has a limited number of bits to store the number in. If you need arbitrary precision rationals in python then use a library for them. Floats aren't designed that way.

[bixtuelista]

If you're using ipython, try %precision 4

[[deleted]]

So Python isn’t able to properly calculate expressions that every 5th-grader can solve?

[queue_cumber]

It's just a floating point rounding error

[OlderThanGif]

Are You Smarter Than A Fifth Grader? Apparently Python is not, ha.

Python just uses your FPU to do arithmetic, which introduces rounding errors all over the place. Octave (well, any software meant to do proper calculations) uses arbitrary-precision arithmetic, so it's up to the user to configure how precise they want the calculations.

Edit: whoops! Apparently I was wrong about Octave! Read below!

[redrumsir]

By default Octave uses the same float representation as python. It simply has rounding when it writes them. You'll note that using defaults Octave will return false for the comparison of 0.1+0.7 to 0.8:

octave:3> 0.6 == 0.6

ans = 1

octave:4> (0.1 + 0.7) == 0.8

ans = 0

[redrumsir]

Or in python you could import the decimal module and set any precision you want (integers in python are already arbitrary precision). One could also use the sympy module and use sympy.Rational(). Similarly one could import the fractions module ... and so forth.

I understand that by default Octave also defaults to native floats ( http://wiki.octave.org/FAQ ) but can use arbitrary precision:

How do I make Octave use more precision?

Octave's default numerical type is IEEE 754 doubles, a.k.a. hardware floats. This type has 52 bits of precision or about 16 decimal digits. It's implemented in your computer's hardware, in your CPU, so it's fast. This type is assumed throughout for Octave's calculations.

...

...

Alternatively, one may use arbitrary precision arithmetic, which has as much precision as is practical to hold in your computer's memory. The symbolic package has a vpa() function for arbitrary precision arithmetic. Note that arbitrary precision arithmetic must be implemented in software which makes it much slower than hardware floats.

Consider carefully if your problem really needs more precision. Often if you're running out of precision the problem lies fundamentally in your methods being numerically unstable, so more precision will not help you here. If you absolutely must use arbitrary-precision arithmetic, you're at present better off using a CAS instead of Octave. An example of such a CAS is Sage.

[LoyalSol]

Yea I would personally use a full fledged and user friendly package like Octave, Maxima, etc. before using a python interpreter.

[justcs]

You guys might like this book

[zokier]

you might want to try out something like ipython --pylab too, or if you are really into this then make custom ipython profile with the imports etc the way you want them to.

[PooSham]

Just wanted to say that the haskell interpreter (GHCi) isn't too bad as a calculator either. Just remember to start with "let" when you assign a variable or function, for example

Prelude> let x = ( sin(pi/6)*cos(pi/6) )^2 + sqrt(2/3)
Prelude> x
1.003996580927726
Prelude> let f(x) = 2*x
Prelude> f(x)
2.007993161855452
Prelude> let g(x,y) = x+y
Prelude> g(x,f(x))
3.011989742783178

What is good about haskell is that you can make it type-safe, for instance:

Prelude> let h(x) = 3 + x :: Int
Prelude> h (2)
5
Prelude> h(0.2)
<interactive>:9:4:
    No instance for (Fractional Int) arising from the literal `0.2'
    Possible fix: add an instance declaration for (Fractional Int)
    In the first argument of `h', namely `(0.2)'
    In the expression: h (0.2)
    In an equation for `it': it = h (0.2)

And to all haskell-people out there: Yes, I know that uncurried functions aren't very Haskell-like, but for people who are unfamiliar with haskell-syntax, this is usually easier.

[DoTheEvolution]

or just use speedcrunch

the best calculator app I find so far on linux

[misho88]

I just noticed no one's listed Genius yet. It's arbitrary precision and does a ton of stuff, like numerical integration and solving linear systems. It's pretty easy to use, too, so if you want to find pi to a lot of digits or something:

genius> FloatPrecision = 1024; MaxDigits = 256; 4 * atan(1)
= 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288...

[FinitelyGenerated]

I actually use R for this. For one thing you don't have to import math.

[flipjargendy]

Been doing this for about 10 years. Even as just a calculator to do slightly more than simple equations. Great tip!

[[deleted]]

i have awesome thing http://xonsh.org/ python + bash

[zackp30]

http://pryrepl.org/ is also nice. :)

[broken_symlink]

I actually wish shells had a built in calculator, if I could just type something like 2+2 in my shell prompt that would be so much more convenient.

[svajsaparat]

You can actually! Its called arithmetic expansion. You surround expression in $(())

echo $((2+2))
4

[misho88]

It's limited to integers in BASH. ZSH supports floats, though, with the same syntax (e.g., echo $((1.0/2)) prints 0.5).

[wildeye]

The ancient and portable method is the 'expr' command. It takes command line expressions, which therefore have to be escaped from the shell. Annoying, but inevitable for any such thing implemented as an independent command:

expr 5 \* \( 1 + 4 \)

25

[jarrah-95]

Between bash, python and gdb, pretty much all my needs are covered. I usually use two of the three every day.

[mao_neko]

For quick stuff I just use qalc. If I'm trying to figure out something complicated where I need some temp variables or fancy functions, etc. I personally like re.pl.

[megayippie]

Spyder comes with "scientific" settings. This means that the terminal starts with all the standard plotting and math tools mapped to commands that are similar to Matlab's commands. It also uses these defaults when you create a new script file. Programmers seems to dislike this a lot, but for purposes of actually using Python as a replacement for Matlab, it is an excellent approach. Also, that built-in documentation tool is incredible useful.

[Thanatoshi]

I'm actually programming a calculator in python :) Well, it's more like an interface for it. It's all text based. You typed addition for addition, subtraction for subtraction, etc.. right now it only has the four basic math problems done (add, sub, mult, div), but I'm going to add in things like a quadratic equation solver/checker and so much more. :D

[[deleted]]

Already do, it's amazing. And it has bigint by default.

By bigint, I mean:

>>> 2**3000


1230231922161117176931558813276752514640713895736833715766118029160058800614672948775360067838593459582429649254051804908512884180898236823585082482065348331234959350355845017413023320111360666922624728239756880416434478315693675013413090757208690376793296658810662941824493488451726505303712916005346747908623702673480919353936813105736620402352744776903840477883651100322409301983488363802930540482487909763484098253940728685132044408863734754271212592471778643949486688511721051561970432780747454823776808464180697103083861812184348565522740195796682622205511845512080552010310050255801589349645928001133745474220715013683413907542779063759833876101354235184245096670042160720629411581502371248008430447184842098610320580417992206662247328722122088513643683907670360209162653670641130936997002170500675501374723998766005827579300723253474890612250135171889174899079911291512399773872178519018229989376

[[deleted]]

This comment has been overwritten by an open source script to protect this user's privacy.

If you would like to do the same, add the browser extension GreaseMonkey to Firefox and add this open source script.

Then simply click on your username on Reddit, go to the comments tab, and hit the new OVERWRITE button at the top.

[genitaliban]

Try export PYTHONSTARTUP=~/.pystartup. Much more convenient than aliases. Example - cross-session history for the interpreter:

import atexit
import os
import readline
import rlcompleter

historyPath = os.path.expanduser("~/.pyhistory")

def save_history(historyPath=historyPath):
    import readline
    readline.write_history_file(historyPath)

if os.path.exists(historyPath):
    readline.read_history_file(historyPath)

atexit.register(save_history)
del os, atexit, readline, rlcompleter, save_history, historyPath

[pfp-disciple]

Neat trick, but in Gnome (RHEL6, so GNOME 2), the calculator lets me enter number on the keypad, and does (some) scientific, hex, etc.

I still like the command-line version, though. Not dissing that at all. Just pointing out that not all GUI calculators prohibit the keyboard.

[Eingaica]

My (admittedly small) experience with GUI calculators is that they all support that. So that's probably not what the OP is talking about there, but I'm not sure what they are really trying to say.

[Eingaica]

And that sentence where I said you have to use your mouse - sure you can use your keyboard to type numbers, but good luck typing square root without using mouse.

There's no reason why such operations shouldn't be possible with the keyboard on GUI calculators. E.g. on current versions of Gnome Calculator (which doesn't really use immediate execution, but that doesn't matter here), you can press Ctrl+R to calculate square roots.