Tropical algebra overloading: Difference between revisions

Algol 68 allows operator overloading and even re-defining the built in operators (though the latter is probably frowned on).<br>

Either existing symbols or new symbols or "bold" (normally uppercase) words can be used. Unfortunately, (X) and (+) can't be used as operator symbols, so X is used for (X), + for (+) and ^ for exponentiaion. The standard + and ^ operators are redefined.<br>

 

REAL minus inf = - max real;

check( 5 X ( 8 + 7 ), "5 (X) ( 8 (+) 7 ) = 5 (X) 8 (+) 5 (X) 7", 5 X 8 + 5 X 7 )

END

{{out}}

<pre>

 

=={{header|C++}}==

#include <optional>

 

}

 

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

typed ;

 

[ 5 8 ⊗ 5 7 ⊗ ⊕ ]

[ 8 7 ⊕ 5 ⊗ 5 8 ⊗ 5 7 ⊗ ⊕ = ]

{{out}}

<pre>

=={{header|FreeBASIC}}==

Using preprocessor macros.

#define tropicalAdd(x,y) iif((x > y), (x), (y))

#define tropicalMul(x,y) (x + y)

Print "tropicalMul(5,tropicalAdd(8,7)) = tropicalAdd(tropicalMul(5,8),tropicalMul(5,7)) = "; _

CBool(tropicalMul(5,tropicalAdd(8,7)) = tropicalAdd(tropicalMul(5,8),tropicalMul(5,7)))

 

 

{{trans|Wren}}

Go doesn't support operator overloading so we need to use functions instead.

 

import (

fmt.Printf("%s ⊗ %s ⊕ %s ⊗ %s = %s\n", c, d, c, e, g)

fmt.Printf("%s ⊗ (%s ⊕ %s) == %s ⊗ %s ⊕ %s ⊗ %s is %t\n", c, d, e, c, d, c, e, f.eq(g))

 

{{out}}

=={{header|Haskell}}==

Looks like the Haskell pretty printer thinks the single quote in 'Maxima begins a character constant.

 

import Prelude hiding ((^))

 

opError :: String -> a

 

{{out}}

 

=={{header|Julia}}==

⊗(x, y) = x + y

↑(x, y) = (@assert round(y) == y && y > 0; x * y)

@show 5 ⊗ 8 ⊕ 5 ⊗ 7

@show 5 ⊗ (8 ⊕ 7) == 5 ⊗ 8 ⊕ 5 ⊗ 7

<pre>

2 ⊗ -2 = 0

We also defined the -Inf value as a constant, MinusInfinity.

 

 

type MaxTropical = distinct float

echo &"5 ⊗ (8 ⊕ 7) = {x}"

echo &"5 ⊗ 8 ⊕ 5 ⊗ 7 = {y}"

 

{{out}}

=={{header|Phix}}==

Phix does not support operator overloading. I trust max is self-evident, sq_add and sq_mul are existing wrappers to the + and * operators, admittedly with extra (sequence) functionality we don't really need here, but they'll do just fine.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.1"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (minor/backportable bugfix rqd to handling of -inf in printf[1])</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"tropicalMul(5,tropicalAdd(8,7)) == tropicalAdd(tropicalMul(5,8),tropicalMul(5,7)) = %t\n"</span><span style="color: #0000FF;">,</span>

<span style="color: #0000FF;">{</span><span style="color: #000000;">tropicalMul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tropicalAdd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">))</span> <span style="color: #0000FF;">==</span> <span style="color: #000000;">tropicalAdd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tropicalMul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">),</span><span style="color: #000000;">tropicalMul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">))})</span>

<small>[1]This task exposed a couple of "and o!=inf" that needed to become "and o!=inf and o!=-inf" in builtins\VM\pprintfN.e - thanks!</small>

{{out}}

 

=={{header|Python}}==

 

class MaxTropical:

print("5 * (8 + 7) == 5 * 8 + 5 * 7", j * (l + k) == j * l + j * k)

 

<pre>

2 * -2 == 0

=={{header|R}}==

R's overloaded operators, denoted by %_%, have different precedence order than + and *, so parentheses are needed for the distributive example.

 

"%*%" <- function(x, y) x + y

cat("5 %*% 8 %+% 5 %*% 7 ==", (5 %*% 8) %+% (5 %*% 7), "\n")

cat("5 %*% 8 %+% 5 %*% 7 == 5 %*% (8 %+% 7))", 5 %*% (8 %+% 7) == (5 %*% 8) %+% (5 %*% 7), "\n")

<pre>

2 %*% -2 == 0

No need to overload, define our own operators with whatever precedence level we want. Here we're setting precedence equivalent to existing operators.

 

sub infix:<⊗> (Real $a, Real $b) is equiv(&[×]) { $a + $b }

sub infix:<↑> (Real $a, Int $b where * ≥ 0) is equiv(&[**]) { [⊗] $a xx $b }

is-deeply( 5 ↑ 7, 35, '5 ↑ 7 == 35' );

is-deeply( 5 ⊗ (8 ⊕ 7), 5 ⊗ 8 ⊕ 5 ⊗ 7, '5 ⊗ (8 ⊕ 7) == 5 ⊗ 8 ⊕ 5 ⊗ 7');

{{out}}

<pre>ok 1 - 2 ⊗ -2 == 0

=={{header|REXX}}==

'''REXX''' &nbsp; doesn't support operator overloading, &nbsp; so functions are needed to be used instead.

call negInf; @x= '(x)'; @a= '(+)'; @h= '(^)'; @e= 'expression'; @c= 'comparison'

numeric digits 1000 /*be able to handle negative infinity. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

isRing: procedure; parse arg a,b; if ABnInf() then return negInf /*return -∞ */

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

{{trans|Go}}

Vlang doesn't support operator overloading so we need to use functions instead.

const (

println("$c ⊗ $d ⊕ $c ⊗ $e = $g")

println("$c ⊗ ($d ⊕ $e) == $c ⊗ $d ⊕ $c ⊗ $e is ${f.eq(g)}")

 

{{out}}

 

=={{header|Wren}}==

 

class MaxTropical {

System.print("%(c) ⊗ (%(d) ⊕ %(e)) = %(f)")

System.print("%(c) ⊗ %(d) ⊕ %(c) ⊗ %(e) = %(g)")

 

{{out}}