Arithmetic/Integer: Difference between revisions

[[Category:Arithmetic operations]]

[[Category:Arithmetic]]

For remainder, indicate whether its sign matches the sign of the first operand or of the second operand, if they are different.

 

 

=={{header|0815}}==

|~>|~#:end:>

<:61:x<:3d:=<:20:$==$~$=${~>%<:2c:~$<:20:~$

}:ml:x->{x{=>~*>{x<:1:-#:ter:^:ml:

}:ter:<:61:x<:5e:=<:20:$==$~$$=$<:62:x<:3D:=<:20:$==$~$=${{~%

{{Out}}

<pre>

a % b = 2

a ^^ b = 510

</pre>

 

=={{header|6502 Assembly}}==

Code is called as a subroutine (i.e. JSR Arithmetic). Specific OS/hardware routines for user input and printing are left unimplemented.

TXA

PHA

TAX

PLA

The 6502 has no opcodes for multiplication, division, or modulus; the routines for multiplication, division, and modulus given above can be heavily optimized at the expense of some clarity.

 

=={{header|ABAP}}==

 

" Read in the two numbers from the user.

write: / 'Integer quotient:', lv_result. " Truncated towards zero.

lv_result = p_first mod p_second.

 

=={{header|ACL2}}==

:set-state-ok t

 

(cw "Product: ~x0~%" (* a b))

(cw "Quotient: ~x0~%" (floor a b))

 

=={{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}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

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))

<pre>

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

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

a UP b = a**b = a↑b = +1.499007808785573768814747570e+288

</pre>

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}}==

print "add:", $1 + $2

print "sub:", $1 - $2

print "mod:", $1 % $2 # same sign as first operand

print "exp:", $1 ^ $2

 

For division and modulus, Awk should act like C.

 

=={{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|BASIC256}}==

input "enter a number ?", a

input "enter another number ?", b

print "remainder or modulo " + a + " % " + b + " = " + (a % b)

print "power " + a + " ^ " + b + " = " + (a ^ b)

 

=={{header|Batch File}}==

 

=={{header|BBC BASIC}}==

INPUT "Enter the second integer: " second%

PRINT "The integer quotient is " ; first% DIV second% " (rounds towards 0)"

PRINT "The remainder is " ; first% MOD second% " (sign matches first operand)"

 

=={{header|bc}}==

"add: "; a + b

"sub: "; a - b

"mod: "; a % b /* same sign as first operand */

"pow: "; a ^ b

 

=={{header|Befunge}}==

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

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

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

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

 

=={{header|Bracmat}}==

The remainder returned by mod is non-negative. Furthermore, <code>div$(!a.!d)*!d+mod$(!a.!d):!a</code> for all integer <code>!a</code> and <code>!d</code>, <code>!d:~0</code>.

= put$"Enter two integer numbers, separated by space:"

& get':(~/#?k_~/#?m|quit:?k)

& out$("Exponentiation:" !k^!m)

& done;

 

=={{header|Brat}}==

Inspired by the second VBScript version.

y = ask("Second number: ").to_i

 

#Remainder uses sign of right hand side

[:+ :- :* :/ :% :^].each { op |

 

=={{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));

}

<pre>5 + 3 = 8

5 - 3 = 2

5 % 3 = 2

5 to the power of 3 = 125</pre>

 

=={{header|Chef}}==

 

 

Only reads single values.

Clean 1st mixing bowl.

 

 

=={{header|Clipper}}==

? "a+b", a + b

? "a-b", a - b

// Exponentiation is also a base arithmetic operation

? "a**b", a ** b

 

=={{header|Clojure}}==

(println "Enter x and y")

(let [x (read), y (read)]

(doseq [op '(+ - * / Math/pow rem)]

(let [exp (list op x y)]

 

<pre>user=> (myfunc)

 

=={{header|COBOL}}==

PROGRAM-ID. Int-Arithmetic.

 

 

GOBACK

 

=={{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.

=={{header|Component Pascal}}==

Works with Gardens Point Component Pascal

MODULE Arithmetic;

IMPORT CPmain,Console,RTS;

Console.WriteString("x MOD y >");Console.WriteInt(x MOD y,6);Console.WriteLn;

END Arithmetic.

command: <i>cprun Arithmetic 12 23</i><br/>

<pre>

x + y > 35

</pre>

Works with BlackBox Component Builder

MODULE Arithmetic;

IMPORT StdLog,DevCommanders,TextMappers;

END Go;

END Arithmetic.

Command: Arithmetic.Go 12 23 ~ <br/>

<pre>

x + y > 35

x MOD y > 12

</pre>

=={{header|D}}==

 

void main() {

writeln("a % b = ", a % b);

writeln("a ^^ b = ", a ^^ b);

{{out}}

<pre>a = -16, b = 5

a % b = -1

a ^^ b = -1048576</pre>

===Shorter Version===

Same output.

 

void main() {

writeln("a = ", a, ", b = ", b);

 

mixin(`writeln("a ` ~ op ~ ` b = ", a` ~ op ~ `b);`);

Division and modulus are defined as in C99.

 

=={{header|dc}}==

Use whitespace to separate. Example: 2 3

Use underscore for negative integers. Example: _10

[div: ]P la lb / p sz [truncates toward zero]sz

[mod: ]P la lb % p sz [sign matches first operand]sz

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

WriteLn(Format('%d %% %d = %d', [a, b, a mod b])); // matches sign of the first operand

WriteLn(Format('%d ^ %d = %d', [a, b, Trunc(Power(a, b))]));

 

=={{header|DWScript}}==

var b := StrToInt(ParamStr(1));

 

PrintLn(Format('%d / %d = %d', [a, b, a div b]));

PrintLn(Format('%d mod %d = %d', [a, b, a mod b]));

 

=={{header|E}}==

 

return `$\

Sum: ${a + b}

Quotient: ${a // b}

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

 

=={{header|ECL}}==

ArithmeticDemo(INTEGER A,INTEGER B) := FUNCTION

ADDit := A + B;

This default behavior can be changed

*/

 

=={{header|Efene}}==

 

run = fn () {

 

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

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

 

=={{header|Eiffel}}==

{{works with|SmartEiffel|2.4}}

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|Elena}}==

 

 

 

=={{header|Erlang}}==

-module(arith).

-export([start/0]).

halt()

end.

 

=={{header|ERRE}}==

PROGRAM INTEGER_ARITHMETIC

 

PRINT("Power ";A;"^";B;"=";(A^B))

END PROGRAM

{{out}}

<pre>Enter a number ? 12

 

=={{header|Euphoria}}==

 

integer a,b

printf(1,"a / b = %g\n", a/b) -- does not truncate

printf(1,"remainder(a,b) = %d\n", remainder(a,b)) -- same sign as first operand

 

<pre>a = 2

b = 3

remainder(a,b) = 2

power(a,b) = 8</pre>

 

=={{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|friendly interactive shell}}==

read a

read b

echo 'a % b =' (math "$a % $b") # Remainder

echo 'a ^ b =' (math "$a ^ $b") # Exponentation

 

=={{header|Frink}}==

This demonstrates normal division (which produces rational numbers when possible), <CODE>div</CODE>, and <CODE>mod</CODE>. <CODE>div</CODE> rounds toward negative infinity (defined as <CODE>floor[x/y]</CODE>). <CODE>mod</CODE> uses the sign of the second number (defined as <CODE>x - y * floor[x/y]</CODE>). All operators automatically produce big integers or exact rational numbers when necessary.

[a,b] = input["Enter numbers",["a","b"]]

ops=["+", "-", "*", "/", "div" ,"mod" ,"^"]

println["$str = " + eval[str]]

}

 

10 + 20 = 30

10 - 20 = -10

10 mod 20 = 10

10 ^ 20 = 100000000000000000000

 

=={{header|GAP}}==

local a, b, f;

f := InputTextUser();

Display(Concatenation(String(a), " ^ ", String(b), " = ", String(a ^ b)));

CloseStream(f);

 

=={{header|GEORGE}}==

R (n) ;

m n + P;

m n × P;

m n div P;

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("%d %% %d = %d\n", a, b, a%b) // same sign as first operand

// no exponentiation operator

<pre>

enter two integers: -5 3

-5 % 3 = -2

</pre>

 

=={{header|Groovy}}==

println """

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

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

"""

 

 

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

a - b = 5 - 3 = 2

 

=={{header|Harbour}}==

? "a+b", a + b

? "a-b", a - b

// Exponentiation is also a base arithmetic operation

? "a**b", a ** b

 

=={{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

 

=={{header|Haxe}}==

public static function main() {

var args =Sys.args();

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|Icon}} and {{header|Unicon}}==

writes("Input 1st integer a := ")

a := integer(read())

write(" a % b = ",a%b, " remainder sign matches a")

write(" a ^ b = ",a^b)

 

=={{header|Inform 7}}==

 

 

Numerically entering is an action applying to one number. Understand "[number]" as numerically entering.

Equation - Division Formula

Q = A / B

 

This solution shows four syntaxes: mathematical operators, English operators, inline equations, and named equations. Division rounds toward zero, and the remainder has the same sign as the quotient.

 

=={{header|J}}==

 

The function <code>bia</code> assembles these results, textually:

 

combine =: ,. ":@,.

bia =: labels combine calc

Quotient: 5

Remainder: 2

 

=={{header|Java}}==

 

=={{header|JavaScript}}==

{{works with|JScript}}

{{works with|SpiderMonkey}}

Note that the operators work the same in all versions of JavaScript; the requirement for specific implementations is in order to get user input.

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

 

print(prompt);

}

<pre>Enter an integer

-147

quotient: a / b = -2

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

 

=={{header|jq}}==

 

def arithmetic:

 

arithmetic

{{Out}}

<pre>

a % b = -2

a | exp = 0.1353352832366127</pre>

 

=={{header|Julia}}==

for op in [+,-,*,div,rem]

println("a $op b = $(op(a,b))")

end

{{Out}}

<pre>julia> arithmetic()

a div b = 0

a rem b = 4</pre>

 

=={{header|LabVIEW}}==

[[File:LabVIEW_Arithmetic_Integer.png]]

 

 

 

=={{header|Lasso}}==

#a + #b // 10

#a - #b // 2

#a % #b // 2

math_pow(#a,#b) // 1296

 

=={{header|LFE}}==

 

(defmodule arith

(export all))

; rem's result takes the same sign as the first operand

(: io format '"~p rem ~p = ~p~n" (list a b (rem a b))))))

 

Usage from the LFE REPL:

> (slurp '"arith.lfe")

#(ok arith)

2 rem 8 = 2

ok

 

=={{header|Liberty BASIC}}==

Note that raising to a power can display very large integers without going to approximate power-of-ten notation.

input "Enter the first integer: "; first

input "Enter the second integer: "; second

print "The remainder is " ; first MOD second; " (sign matches first operand)"

print "The first raised to the power of the second is " ; first ^second

 

=={{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

 

=={{header|Maple}}==

These operations are all built-in. As all operations are exact, there are no rounding issues involved.

DoIt := proc()

local a := readstat( "Input an integer: " ):

NULL # quiet return

end proc:

Here is an example of calling DoIt.

> DoIt();

Input an integer: 15;

Remainder = 3

>

 

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

remainder: 2

exponentiation: 4913</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

disp("integer b: "); b = scanf("%d", 1);

a+b

floor(a/b)

mod(a,b)

 

=={{header|Maxima}}==

[a: read("a"), b: read("b")],

print(a + b),

print(remainder(a, b)),

a^b

 

=={{header|MAXScript}}==

y = getKBValue prompt:"Second number:"

 

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

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

 

=={{header|Mercury}}==

:- module arith_int.

:- interface.

io.set_exit_status(1, !IO)

).

 

=={{header|Metafont}}==

 

message "input number a: ";

s1 := readstring;

outp("mod");

 

 

=={{header|МК-61/52}}==

+ С/П

ИП0 ИП1 - С/П

ИП0 ИП1 / [x] С/П

ИП0 ^ ИП1 / [x] ИП1 * - С/П

 

=={{header|ML/I}}==

 

"" Arithmetic/Integer

"" assumes macros on input stream 1, terminal on stream 2

Division is truncated to the greatest integer

that does not exceed the exact result. Remainder matches

 

=={{header|Modula-2}}==

 

IMPORT InOut;

InOut.WriteString ("a MOD b = "); InOut.WriteInt (a MOD b, 9); InOut.WriteLn;

InOut.WriteLn;

Enter two integer numbers : 12 7

a + b = 19

 

=={{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|Nemerle}}==

Adapted nearly verbatim from C# solution above. Note that I've used the exponentiation operator (**), but Math.Pow() as used in the C# solution would also work.

class Program

Console.WriteLine("{0} ** {1} = {2}", a, b, a ** b);

}

 

=={{header|NetRexx}}==

{{trans|REXX}}

 

 

say "enter 2 integer values separated by blanks"

 

return

<pre style="height: 15ex; overflow:scroll;">

enter 2 integer values separated by blanks

=={{header|NewLISP}}==

 

; oofoe 2012-01-17

 

 

(exit) ; NewLisp normally goes to listener after running script.

 

<pre>

Please type in an integer and press [enter]: 17

</pre>

 

 

var

str = opt.cmdLineRest.split

a: int = 0

b: int = 0

try:

a = parseInt(str[0])

b = parseInt(str[1])

quit("Invalid params. Two integers are expected.")

<pre>

</pre>

 

=={{header|NSIS}}==

All Arithmetic in NSIS is handled by the [http://nsis.sourceforge.net/Docs/Chapter4.html#4.9.10.2 IntOp] instruction. It is beyond the scope of this task to implement user input (a fairly involved task), so I will be providing hard-coded values simulating the user input, with the intention of later adding the user-input piece.

Push $0

Push $1

Pop $1

Pop $0

 

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE Arithmetic;

IMPORT In, Out;

Out.String("x MOD y >");Out.Int(x MOD y,6);Out.Ln;

END Arithmetic.

<pre>

Give two numbers: 12 23

x MOD y > 12

</pre>

=={{header|Objeck}}==

class Arithmetic {

function : Main(args : System.String[]) ~ Nil {

}

}

 

=={{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 *)

 

=={{header|Openscad}}==

 

echo (a-b); /* Difference */

echo (a*b); /* Product */

echo (a/b); /* Quotient */

 

=={{header|Oz}}==

StdIn = {New class $ from Open.file Open.text end init(name:stdin)}

 

"A^B = "#{Pow A B}

]

 

=={{header|PARI/GP}}==

Integer division with <code>\</code> rounds to <math>-\infty</math>. There also exists the <code>\/</code> round-to-nearest (ties to <math>+\infty</math>) operator. Ordinary division <code>/</code> does not round but returns rationals if given integers with a non-integral quotient.

print(a+b);

print(a-b);

print(a%b);

print(a^b);

 

=={{header|Pascal}}==

 

var

writeln('a*b = ', a*b);

writeln('a/b = ', a div b, ', remainder ', a mod b);

 

=={{header|Perl}}==

{{works with|Perl|5.x}}

my $b = <>;

 

"remainder: ", $a % $b, "\n",

"exponent: ", $a ** $b, "\n"

 

 

 

 

=={{header|PHL}}==

 

 

extern printf;

return 0;

 

=={{header|PHP}}==

$a = fgets(STDIN);

$b = fgets(STDIN);

"truncating quotient: ", (int)($a / $b), "\n",

"flooring quotient: ", floor($a / $b), "\n",

 

=={{header|PicoLisp}}==

(prinl "Add " (+ A B))

(prinl "Subtract " (- A B))

(prinl "Div/rnd " (*/ A B)) # Rounds to next integer

(prinl "Modulus " (% A B)) # Sign of the first operand

=={{header|Piet}}==

[[File:PietArithmaticInteger.png]]<br>

 

=={{header|PL/I}}==

get list (a, b);

put skip list (a+b);

put skip list (trunc(a/b)); /* truncates towards zero. */

put skip list (mod(a, b)); /* Remainder is always positive. */

 

=={{header|Pop11}}==

 

vars itemrep;

incharitem(charin) -> itemrep;

printf(a * b, 'a * b = %p\n');

printf(a div b, 'a div b = %p\n');

 

=={{header|PostScript}}==

/x exch def

/y exch def

x y mod =

x y exp =

=={{header|PowerShell}}==

$b = [int] (Read-Host Second Number)

 

Write-Host "Quotient: $($a / $b)"

Write-Host "Quotient, round to even: $([Math]::Round($a / $b))"

Numbers are automatically converted to accomodate for the result. This means not only that Int32 will be expanded to Int64 but also that a non-integer quotient will cause the result to be of a floating-point type.

 

 

No exponentiation operator exists, but can be worked around with the .NET BCL:

=={{header|ProDOS}}==

include arithmeticmodule

:a

editvar /newvar /value=d /title=Do you want to calculate more numbers?

if -d- /hasvalue yes goto :a else goto :end

 

:a

editvar /newvar /value=a /title=Enter first integer:

editvar /newvar /value=d /title=Do you want to calculate more numbers?

if -d- /hasvalue yes goto :a else goto :end

 

=={{header|Prolog}}==

Remainder (`rem`) matches the sign of its first operand.

 

 

print_expression_and_result(M, N, Operator) :-

maplist( print_expression_and_result(M, N), [+,-,*,//,rem,^] ).

 

 

Use thus:

 

?- arithmetic_integer.

|: 5.

5^7 is 78125

true.

 

=={{header|PureBasic}}==

Define a, b

Input()

 

=={{header|Python}}==

 

y = int(raw_input("Number 2: "))

 

 

## Only used to keep the display up when the program ends

 

Notes: In Python3 ''raw_input()'' will be renamed to ''input()'' (the old ''input()'' built-in will go away, though one could use ''eval(input())'' to emulate the old ... and ill-advised ... behavior). Also a better program would wrap the attempted ''int()'' conversions in a ''try: ... except ValueError:...'' construct such as:

 

while True: # retrying ...

try:

x = getnum("Number1: ")

y = getnum("Number2: ")

 

(In general it's good practice to perform parsing of all input in exception handling blocks. This is especially true of interactive user input, but also applies to data read from configuration and other files, and marshaled from other processes via any IPC mechanism).

 

=== Python 3.0 compatible code ===

for op in "+ - * // % **".split():

expr = "%(x)s %(op)s %(y)s" % vars()

 

arithmetic(12, 8)

<pre>12 + 8 => 20

12 - 8 => 4

20 % 4 => 0

20 ** 4 => 160000</pre>

 

=={{header|R}}==

a <- scan(nmax=1, quiet=TRUE)

cat("insert number ")

print(paste('a%%b=', a%%b))

print(paste('a^b=', a^b))

 

=={{header|Racket}}==

(define (arithmetic x y)

(arithmetic 8 12)

<pre>

(+ 8 12) => 20

(lcm 8 12) => 24

</pre>

=={{header|Raven}}==

 

' Number 2: ' print expect 0 prefer as y

 

x y * " product: %d\n" print

x y / " quotient: %d\n" print

 

=={{header|REBOL}}==

Title: "Integer"

URL: http://rosettacode.org/wiki/Arithmetic/Integer

]

]

 

 

<pre>Please type in an integer, and press [enter]: 17

Please enter another integer: -4

Remainder sign matches: first

Exponentiation: 1.19730367213036E-5</pre>

 

=={{header|Retro}}==

Retro's arithmetic functions are based on those in [[Forth]]. The example is an adaption of the one from Forth.

 

=={{header|REXX}}==

 

 

<pre>

 

</pre>

 

=={{header|Ruby}}==

 

x = gets.to_i # to check errors, use x=Integer(gets)

y = gets.to_i

"Quotient: #{x.fdiv(y)}", # float

"Remainder: #{x%y}", # same sign as second operand