Arithmetic/Integer: Difference between revisions

 

 

=={{header|Ada}}==

with Ada.Integer_Text_IO;

 

Put_Line("a-b = " & Integer'Image(A - B));

Put_Line("a*b = " & Integer'Image(A * B));

Put_Line("a**b = " & Integer'Image(A ** B));

 

 

=={{header|Aikido}}==

var b = 0

stdin -> a // read int from stdin

println ("a*b=" + (a * b))

println ("a/b=" + (a / b))

 

=={{header|ALGOL 68}}==

LONG INT a=355, b=113;

printf(($"a OVER b = a%b = a÷b = "gl$, a % b));

printf(($"a MOD b = a%*b = a%×b = a÷×b = a÷*b = "gl$, a %* b));

printf(($"a UP b = a**b = a↑b = "gl$, a ** b))

a OVER b = a%b = a÷b = +3

a MOD b = a%*b = a%×b = a÷×b = a÷*b = +16

INT quotient:=355, remainder;

 

=={{header|AmigaE}}==

DEF a, b, t

WriteF('A = ')

WriteF('A*B=\d\nA/B=\d\n', Mul(a,b), Div(a,b))

WriteF('A mod B =\d\n', Mod(a,b))

 

=={{header|AutoHotkey}}==

The quotient rounds towards 0 if both inputs are integers or towards negative infinity if either input is floating point. The sign of the remainder is always the same as the sign of the first parameter (dividend).

Gui, Add, Edit, vb, -3

Gui, Add, Button, Default, Compute

; fallthrough

GuiClose:

 

=={{header|AWK}}==

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

print a + b

print a - b

print a / b

print a mod b

Truncate towards: 0

 

Remainder sign matches: first operand

=={{header|Befunge}}==

v,+55.+g00:,,,,"A+B="<

>"=B-A",,,,:00g-.55+,v

v,+55.*g00:,,,,"A*B="<

>"=B/A",,,,:00g/.55+,v

 

 

=={{header|C}}==

#include <stdlib.h>

 

printf("a%%b = %d\n", a%b); /* same sign as first operand (in C99) */

return 0;

 

=={{header|C sharp|C#}}==

 

class Program

Console.WriteLine("{0} to the power of {1} = {2}", a, b, Math.Pow(a, b));

}

5 - 3 = 2

5 * 3 = 15

5 / 3 = 1

5 % 3 = 2

 

=={{header|Chef}}==

 

 

Only reads single values.

Clean 1st mixing bowl.

 

 

=={{header|Common Lisp}}==

 

(mapc

(lambda (op)

(format t "~a => ~a~%" (list op a b) (funcall (symbol-function op) a b)))

'(+ - * mod rem floor ceiling truncate round expt))

 

Common Lisp's integer division functions are <code>floor</code>, <code>ceiling</code>, <code>truncate</code>, and <code>round</code>. They differ in how they round their quotient.

quotient * divisor + remainder = dividend .

<code>(mod a b)</code> and <code>(rem a b)</code> return numbers equal to the secondary values of <code>(floor a b)</code> and <code>(truncate a b)</code>, respectively.

 

=={{header|D}}==

 

 

 

=={{header|E}}==

 

return `$\

Sum: ${a + b}

Quotient: ${a // b}

Remainder: ${a % b}$\n`

 

=={{header|Efene}}==

 

run = fn () {

 

io.format("Quotient: ~p~n", [A / B])

io.format("Remainder: ~p~n", [A % B])

 

=={{header|Eiffel}}==

In a file called main.e:

creation make

feature make is

print("%N");

end

Note that there actually is a builtin modulo operator (\\). However, it seems impossible to use that instruction with SmartEiffel.

 

=={{header|Factor}}==

math.parser prettyprint ;

 

[ gcd "gcd: " write . drop ]

[ lcm "lcm: " write . ]

 

b=12

sum: 20

minimum: 8

gcd: 4

 

 

=={{header|FALSE}}==

\$@$@$@$@$@$@$@$@$@$@\ { 6 copies }

"sum = "+."

quotient = "/."

modulus = "/*-."

 

=={{header|Forth}}==

To keep the example simple, the word takes the two numbers from the stack. '''/mod''' returns two results; the stack effect is ( a b -- a%b a/b ).

cr ." a=" over . ." b=" dup .

cr ." a+b=" 2dup + .

cr ." a*b=" 2dup * .

cr ." a/b=" /mod .

 

Different host systems have different native signed division behavior. ANS Forth defines two primitive double-precision signed division operations, from which the implementation may choose the most natural to implement the basic divide operations ( / , /mod , mod , */ ). This is partly due to differing specifications in the two previous standards, Forth-79 and Forth-83.

 

SM/REM ( d n -- rem div ) \ symmetric

 

In addition, there are unsigned variants.

 

 

=={{header|Fortran}}==

In ANSI FORTRAN 77 or later:

PRINT *, 'Type in two integer numbers separated by white space',

+ ' and press ENTER'

+ 'exponentiation is an intrinsic op in Fortran, so...'

PRINT *, ' A ** B = ', (A ** B)

 

 

=={{header|Go}}==

 

=={{header|Groovy}}==

println """

a + b = ${a} + ${b} = ${a + b}

a - b = ${a} - ${b} = ${a - b}

a * b = ${a} * ${b} = ${a * b}

a % b = ${a} % ${b} = ${a % b}

 

a ** b = ${a} ** ${b} = ${a ** b}

"""

 

 

<pre> a + b = 5 + 3 = 8

a - b = 5 - 3 = 2

a * b = 5 * 3 = 15

a % b = 5 % 3 = 2

 

Exponentiation is also a base arithmetic operation in Groovy, so:

a ** b = 5 ** 3 = 125</pre>

 

=={{header|Haskell}}==

 

a <- readLn :: IO Integer

b <- readLn :: IO Integer

putStrLn $ "a `quot` b = " ++ show (a `quot` b) -- truncates towards 0

putStrLn $ "a `rem` b = " ++ show (a `rem` b) -- same sign as first operand

 

public static function main() {

trace("a+b = " + (a+b));

trace("a-b = " + (a-b));

trace("a%b = " + (a%b));

}

 

=={{header|HicEst}}==

All numeric is 8-byte-float. Conversions are by INT, NINT, FLOOR, CEILING, or Formatted IO

WRITE(Name) A, B

WRITE() ' A + B = ', A + B

WRITE() 'remainder of A / B = ', MOD(A, B) ! same sign as A

WRITE() 'A to the power of B = ', A ^ B

A + B = 1

A - B = 9

remainder of A / B = 1

A to the power of B = 16E-4

 

=={{header|J}}==

 

 

Sum: 20

Difference: 14

Quotient: 5

Remainder: 2

 

=={{header|Java}}==

 

 

 

var b = parseInt(get_input("Enter an integer"), 10);

 

WScript.Echo("difference: a - b = " + (a - b));

WScript.Echo("product: a * b = " + (a * b));

WScript.Echo("remainder: a % b = " + (a % b));

 

print(prompt);

}

<pre>Enter an integer

-147

difference: a - b = -210

product: a * b = -9261

remainder: a % b = -21</pre>

 

=={{header|Logo}}==

(print [a =] :a)

(print [b =] :b)

(print [a / b =] int :a / :b)

(print [a mod b =] modulo :a :b)

 

Each infix operator also has a prefix synonym (sum, difference, product, quotient). Sum and product can also have arity greater than two when used in parentheses (sum 1 2 3). Infix operators in general have high precedence; you may need to enclose their arguments in parentheses to obtain the correct expression.

 

=={{header|LSE64}}==

2dup : over over

 

" A*B=" ,t 2dup * , nl \

" A/B=" ,t 2dup / , nl \

 

=={{header|Lua}}==

local y = io.read()

 

print ("Quotient: " , (x / y)) -- Does not truncate

print ("Remainder: " , (x % y)) -- Result has sign of right operand

 

=={{header|M4}}==

 

Because of the particular nature of M4, the only user-input is the code itself. Anyway the following code can be used:

eval(A-B)

eval(A*B)

eval(A/B)

 

once saved in a file, e.g. <tt>operations.m4</tt>:

or using a sort of ''driver'':

 

define(`B', 6)dnl

 

Mathematica has all the function built-in to handle this task. Example:

b = Input["Give me another integer please!"];

Print["You gave me ", a, " and ", b];

Print["difference: ", a - b];

Print["product: ", a b];

Print["remainder: ", Mod[a, b]];

gives back for input 17 and 3:

sum: 20

difference: 14

integer quotient: 5

remainder: 2

 

=={{header|MAXScript}}==

y = getKBValue prompt:"Second number:"

 

format "Product: %\n" (x * y)

format "Quotient: %\n" (x / y)

 

=={{header|Metafont}}==

 

message "input number a: ";

s1 := readstring;

outp("mod");

 

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

IO.Put("a DIV b = " & Fmt.Int(a DIV b) & "\n");

IO.Put("a MOD b = " & Fmt.Int(a MOD b) & "\n");

 

=={{header|MUMPS}}==

find out the beauty of cyclic algebra as formulated by Niels Henrik Abel (August 5, 1802 – April 6, 1829).</p>

 

Write "Plus",?12,first,"+",second,?25," = ",first+second,!

Write "Minus",?12,first,"-",second,?25," = ",first-second,!

Modulo 0#2 = 0

And 0&2 = 0

 

=={{header|Objeck}}==

class Arithmetic {

DoArithmetic();

}

a := IO.Console->GetInstance()->ReadString()->ToInt();

b := IO.Console->GetInstance()->ReadString()->ToInt();

}

}

 

=={{header|OCaml}}==

let a = read_int ()

and b = read_int () in

Printf.printf "a * b = %d\n" (a * b);

Printf.printf "a / b = %d\n" (a / b); (* truncates towards 0 *)