# Inverse function

Wouldn't it be neat if programming functions could be inverted, just like the mathematical function they implement?

Write a function (or program) that takes one input `x` in any form, that outputs `ln(x)`.
When the bytes of the program are reordered/reversed so that the first byte now is the last byte, it should take one input `x` in any form and output `e^x` instead.

• Approximations are fine, as long as they have at least 3 correct significant figures.
• Your code must be in the same programming language both forwards and backwards.

Let's say this program implements `ln(x)`:

``````abc你好
``````

Then this program has to implement `e^x`:

``````\xBD\xA5\xE5\xA0\xBD\xE4cba
``````

Gold star if you use a language without float support.

This is a weird form of code-golf, so the shortest program wins.

-
"Wouldn't it be neat if programming functions could be inverted, just like the mathematical function they implement?" Some languages (e.g. J and Mathematica) can actually do this for some functions. – Martin Ender Feb 6 at 11:29
Additionally, K2 could approximate an inverse for an arbitrary monadic pure function via its "function inverse" overload of dyadic and triadic `?`, which used the secant method. – JohnE Feb 6 at 15:19
"at least 3 correct significant figures" - over what range? – TLW Feb 6 at 16:48
I realize it's far too late now, but I think this would have been a really nice challenge had comments been disallowed. – Alex A. Feb 6 at 21:45
I actually thought of that when I came up with this challenge @AlexA. but forgot about it while writing the post :P Also that would've made "normal" languages like java, c++ etc basically impossible. – Filip Haglund Feb 7 at 12:59

``````f=log
pxe=f
``````

and in reverse order:

``````f=exp
gol=f
``````

This works without the "comment" trick. Instead each version defines an additional, but unused function (`pxe`/ `gol`).

-
+1 for `gol=f`. – Leif Willerts Feb 6 at 13:22
This is also a valid solution in Julia. – Rainer P. Feb 6 at 23:28

# APL, 3 bytes

``````*⊣⍟
``````

This is a function train. Monadic `*` returns `e^x`, monadic `⍟` returns `ln(x)`. `⊣` is a dyadic function that returns its left argument. Thus, `*⊣⍟` is equivalent to just `*`, and the reverse `⍟⊣*` is equivalent to just `⍟`.

-

## Jelly, 5 4 bytes

Yay, my first Jelly answer. :) Input is via command-line argument.

Jelly has its own code page so each character is one byte.

``````eÆÆl
``````

Try it online!

Reversed:

``````lÆÆe
``````

Try it online!

### Explanation

The `Æ` on its own is an unrecognised token, so it acts the same as a linefeed. That means in either case the main link is only `Æl` or `Æe` which is the 2-character built-in for `exp()` or `ln()` and is by default performed on the first command-line argument.

-

## Javascript, 18 bytes

``````Math.log//pxe.htaM
``````
-
Don't you need a return() or console.log() around it? – OldBunny2800 Feb 6 at 20:32
@OldBunny2800 It evaluates to a function, which should be permissible. – Neil Feb 6 at 20:50
`Math.ln||pxe.htaM` will probably also work. – SuperJedi224 Feb 7 at 12:35
@SuperJedi224 Thanks, that helped me spot the error in my answer! – Neil Feb 7 at 12:50
@Neil I hadn't even noticed that – SuperJedi224 Feb 7 at 18:09

## Seriously, 5 bytes

``````,_.e,
``````

Input, ln, output, then exp on an empty stack (does nothing), and input (does nothing since input is exhausted). Try it online!

Reversed:

``````,e._,
``````

Try it online!

-

# Julia, 7 bytes

``````log#pxe
``````

This is an anonymous function. Assign it to a variable to call it. Evaluates to builtins `log` or `exp` plus a comment.

-
Same answer works for R – Dason Feb 6 at 20:30

# Mathematica, 19 bytes

``````1&#@pxE+0&0+Log@#&1
``````

Reversed:

``````1&#@goL+0&0+Exp@#&1
``````

This was interesting to golf! Mathematica has no line comments / implicit sting endings, so I couldn't take the simple route. Instead, I used the fact that `0 + x == x`, `0 x == 0`, and that `1 x == x`, no matter what `x` is! Testing:

``````In[1]:= (1&#@pxE+0&0+Log@#&1)[x]

Out[1]= Log[x]

In[2]:= (1&#@goL+0&0+Exp@#&1)[x]

x
Out[2]= E
``````
-

# Python2, 73 bytes

io: stdin/stdout

``````from math import*;print log(input())#))(tupni(pxe tnirp;*tropmi htam morf
``````

inverse:

``````from math import*;print exp(input())#))(tupni(gol tnirp;*tropmi htam morf
``````
-
You can shave 10 characters off by using `__import__("math").` instead of – TLW Feb 6 at 16:43

## CJam, 11 bytes

``````rdmle#eemdr
``````

Test it here.

Reversed:

``````rdmee#elmdr
``````

Test it here.

Basically the same comment-trick as the OP's Python answer. `e#` starts a comment. `rd` reads the input and `ml` or `me` computes the logarithm or exponential.

-

# Vitsy, 5 bytes

This is a program that exits on an error.

``````EL^rE
E   E  Push java.lang.Math.E
L     Push log_(top) (input) (ln(input))
^    Push (top)^(input)  (e^(input))
r   Reverse the stack``````

This program exits on an error with ln(input) on the stack.

Try it online! (note that I have put `N` to have visible output)

Then it's inverse:

``Er^LE``

This program exits on an error with e^(input) on the stack.

Try it online!

-

# Fuzzy Octo Guacamole, 7 bytes

non-competing, FOG is newer than the challenge

``````EZO@pZE
``````

This is the equivalent of a function in FOG. It assumes the input is on the stack. This can be assigned to a function by the code `"EZO@pZE""f"o`, where `f` is any single-char name you want to assign. Then use it like any other command. Example: `"EZO@pZE"'f'o^f`.

Explanation:

``````EZO@pZE
E       # Push E (2.718....)
Z      # Reverse stack (it is now [e, input])
O     # log(x, y) which is ln(input)
@    # Exit. (implicit output) Nothing after this gets run.
p   # x^y (power function)
Z  # Reverse stack
E # Push E.
``````

Reversed:

``````EZp@OZE
E       # Push E (2.718....)
Z      # Reverse stack (it is now [e, input])
O     # x^y (power function)
@    # Exit. (implicit output) Nothing after this gets run.
p   # log(x, y) which is ln(input)
Z  # Reverse stack
E # Push E.
``````
-

# Matl, 5 bytes

``````Yl%eZ
``````

`Yl`: log `Ze`: exp `%`: comment

-
Thanks to Dennis, there's an online compiler for MATL – Luis Mendo Feb 6 at 17:34

# Pyth, 12 bytes

Finds `ln(input())`

``````.lQ) " Q1n.^
``````

Finds `e^input()`

``````^.n1Q " )Ql.
``````

Spaces stop implicit printing of strings, each version calculates it then creates a string with the remaining characters.

`ln(x)` mode here

`e^x` mode here

-

# 𝔼𝕊𝕄𝕚𝕟, 8 chars / 10 bytes

``````МŬï//ïŦМ
``````

Just 2 builtins separated by a comment.

-

# Jolf, 9 bytes

Program 1: `exp` of input

``````amoj"jOma
a         print
moj      e^j
"jOma  the rest of the line is captured as a string; implicit printing is restricted.
``````

Program 2: `ln` of input

``````amOj"joma
a         print
mOj      ln(j)
"joma  the rest of the line is captured as a string; implicit printing is restricted.
``````

Bonus points for being a case-insensitive palindrome? Try it here!

-

# J, 8 bytes

The natural logarithm is `^.`, and exponential `^`. The problem is, `.` can only modify a valid verb, otherwise, a spelling error will occur. Thus, we can't use the left argument trick in the APL answer, becuase `^.[^` would cause an error when reversed, as `^[.^` creates an invalid verb. So, we must use comments; but `NB.` is so long :( Fortunately, they both end with `.`, so&ldots; there's that.

Logarithm:

``````^.NB.BN^
``````

Exponential:

``````^NB.BN.^
``````

You can enter them for yourself online!

-

# Java 7, 198 bytes

``````class M{public static void main(String[]a){System.out.print(Math.log(Double.parseDouble(a[0])));}}//}};)))]0[a(elbuoDesrap.elbuoD(pxe.htaM(tnirp.tuo.metsyS{)a][gnirtS(niam diov citats cilbup{M ssalc
``````

AND

``````class M{public static void main(String[]a){System.out.print(Math.exp(Double.parseDouble(a[0])));}}//}};)))]0[a(elbuoDesrap.elbuoD(gol.htaM(tnirp.tuo.metsyS{)a][gnirtS(niam diov citats cilbup{M ssalc
``````

Ungolfed:

``````class M{
public static void main(String[]a){
System.out.print(Math.log(Double.parseDouble(a[0])));
}
}
//}};)))]0[a(elbuoDesrap.elbuoD(pxe.htaM(tnirp.tuo.metsyS{)a][gnirtS(niam diov citats cilbup{M ssalc
``````

AND

``````class M{
public static void main(String[]a){
System.out.print(Math.exp(Double.parseDouble(a[0])));
}
}
//}};)))]0[a(elbuoDesrap.elbuoD(gol.htaM(tnirp.tuo.metsyS{)a][gnirtS(niam diov citats cilbup{M ssalc
``````

# Java 8, 192 bytes

``````class M{public static void main...
``````

replaced with

``````interface M{static void main...
``````

Usage:

``````java -jar M.jar 5
``````

Output:

``````1.6094379124341003

148.4131591025766
``````
-