If I had some expression x^2 + x^3 - 31 and I want to apply a previously defined function f to it, is there a quicker way of doing f(x^2 + x^3 - 31)?
I'm thinking along the lines of Mathematica's x^2 + x^3 - 31 // f, where // applies the function to the expression that precedes it.
Sage is based on Interactive Python. Therefore, every feature in IPython works in SageMath. For example, one feature is automatic-parentheses-and-quotes.
So, if you are too lazy to write parenthesis and commas, then you can turn on the autocall magic and use it by starting the line by /:
sage: %autocall 1
Automatic calling is: Smart
sage: f(x,y,z) = x + y^2 + z^3
sage: /f x+1 y+2 z+3 # no parenthesis, no comma!
(z + 3)^3 + (y + 2)^2 + x + 1
There is also the auto-quoting which can be used if you are too lazy to quote strings. It may be activated by starting the line with a comma:
sage: ,print aujourd'hui # no parenthesis, no comma, no quotes "" !
aujourd'hui
For more information and options, see the documentation of IPython on the link above or as follows:
$ sage -ipython
Python 3.11.1 (main, Sep 2 2023, 13:40:58) [GCC 9.4.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 8.6.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]: ?
@Sébastien Just to point out that it is more equivalent of Mathematica's f@x rather then x // f but anyway I upvoted, as it may be useful for OP in any case.
Thanks @Sébastien, this is useful to know if not quite what I'm looking for. I was hoping to have some feature that would have the function called at the end of the expression its acting on, just for my convenience when working in the interactive shell. But this does also appear to help, in the case that I want to quickly apply a function with multiple arguments without having to type in the parentheses and commas.
Indeed, my answer was not exactly answering the question. In fact, when I do not want to repeat the argument, I most often use the variable _ which always stores the previous output:
sage: f(x) = x^2+1
sage: x^2+x^3-31
x^3 + x^2 - 31
sage: f(_)
(x^3 + x^2 - 31)^2 + 1
Also __ and ___ stores the pre-previous and the pre-pre-previous outputs. Also, _8 stores the 8-th previous output, etc. All this is also documented in the same link I provided in my answer.
Also, with multiple input arguments, notice that you may use * to unwrap the content of a tuple:
sage: def f(a,b,c):
....: return a+b+c
....:
sage: t = (1,2,3)
sage: f(*t)
6
Thus with the underscore storing the previous output you may do:
sage: (5,6,7)
(5, 6, 7)
sage: f(*_)
18
Thanks again @Sébastien , I was aware of _ but your *_ is new to me and I'm sure will be useful in the future. Appreciate your time on this.
Asked: 2024-04-22 12:06:01 +0200
Seen: 255 times
Last updated: May 03
Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.
Please provide a complete code example, including the definition of
f.Hi
But I'm probably missing something here, maybe you could give the function f in order to check with your function as Max Alekseyev asked you ?.
@ortollj@Max Alekseyev Writing
x^2+x^3-31//Sinis equivalent toSin[x^2 + x^3 - 31]in Mathematica. OP asks whether there is equivalent of this syntax//in Sagemath.Let's wait clarification from OP. I read the question differently, and I do not understand why
f(x^2 + x^3 - 31)is not considered quick enough. This may depend on howfis defined, hence I asked for clarification.Sorry for the delay -- @Max Alekseyev@ortollj, I was indeed thinking along the lines of @azerbajdzan , e.g. with
fas something likesinor evenN, so that I could quickly evaluate e.g.cos(23)viacos(23) // N. (But I guess in the latter case, the answer is to just usecos(23).n().)I've now forgotten what the context was (I didn't get any notifications for the comments added here), but I think it's based on using SageMath via an interactive shell. Sometimes I will have an expression defined as the input to one line, and then after executing it, I can access it via the up-arrow key. Rather than scroll across the line to wrap the expression in parentheses and
f, it would be quicker to just type// f, especially as the cursor is already at the end of the expression.