Arithmetic/Integer: Difference between revisions

 

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

 

=={{header|11l}}==

V b = Int(input())

 

print(‘a / b = ’(a I/ b))

print(‘a % b = ’(a % b))

 

=={{header|360 Assembly}}==

The sign of the quotient is determined by the rules of algebra.

The remainder has the same sign as the dividend.

ARITHINT CSECT

USING ARITHINT,R12

BUF DC CL12' '

YREGS

Inputs are in the code: a=53, b=11

{{out}}

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

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

SUB.L D1,D0 ; subtract D1 from D0

DIVU D1,D0

SWAP D0 ;swap the order of the 16-bit halves of D0.

 

Exponentiation doesn't exist but can be implemented in a similar fashion to multiplication on the 6502:

 

;raises D0 to the D1 power. No overflow protection.

MOVE.L D0,D2

DBRA D1,loop_exponent

;output is in D2

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program arith64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output : }}

<PRE>

 

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

DEFINE KEY_Y="43"

DEFINE KEY_N="35"

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Arithmetic_Integer.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Integer_Text_IO;

 

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

{{out}}

<pre>

The Algol W integer division operator (called div) truncates towards zero.<br>

The result of the modulo operator (called rem) has the sign of the first operand when the operands have different signs.

integer a, b;

write( "Enter 2 integers> " );

% operand can be integer, real or complex ) %

write( "a ^ b: ", round( a ** b ) )

 

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

l ← ⎕

r ← ⎕

res ← 6 2 ⍴ 'sum' (l+r) 'diff' (l-r) 'prod' (l×r) 'quot' (⌊l÷r) 'rem' (r|l) 'pow' (l*r)

 

Quotient will round down in this version.

=={{header|AppleScript}}==

 

set i2 to (text returned of (display dialog "Enter another integer value" default answer "")) as integer

 

set exp to i1 ^ i2 -- The result's always a real.

 

 

{{output}}

 

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

 

 

=={{header|Arturo}}==

 

b: to :integer input "give me the second number : "

 

print [a "/" b "=" a/b]

print [a "%" b "=" a%b]

 

{{out}}

 

=={{header|Asymptote}}==

int b = 7;

 

write(" división de a / b = ", division);

write(" resto de a mod b = ", resto);

 

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

[

a : integer,

Print: “a ^ b”;

];

 

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

Same code as [[#Commodore_BASIC|Commodore BASIC]]

==={{header|BaCon}}===

DECLARE a%, b%

INPUT "Enter integer A: ", a%

PRINT a%, " / ", b%, " is ", a% / b%, ", trucation toward zero"

PRINT "MOD(", a%, ", ", b%, ") is ", MOD(a%, b%), ", same sign as first operand"

 

==={{header|Commodore BASIC}}===

20 INPUT "ENTER ANOTHER NUMBER"; B%

30 PRINT "ADDITION:";A%;"+";B%;"=";A%+B%

60 PRINT "INTEGER DIVISION:";A%;"/";B%;"=";INT(A%/B%)

70 PRINT "REMAINDER OR MODULO:";A%;"%";B%;"=";A%-INT(A%/B%)*B%

 

==={{header|True BASIC}}===

! RosettaCode: Integer Arithmetic

! True BASIC v6.007

GET KEY done

END

==={{header|QBasic}}===

{{works with|QuickBasic|4.5}}

print a + b

print a - b

print a / b

print a mod b

Truncate towards: 0

 

 

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

{{works with|Windows 7| or later, haven't checked earlier versions}}

set /p equation=

set /a result=%equation%

echo %result%

pause

 

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

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

}

{{out}}

<pre>5 + 3 = 8

 

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

 

int main()

std::cout << "a/b = " << a/b << ", remainder " << a%b << "\n";

return 0;

 

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

{{out}}

</pre>

Works with BlackBox Component Builder

MODULE Arithmetic;

IMPORT StdLog,DevCommanders,TextMappers;

END Go;

END Arithmetic.

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

{{out}}

 

=={{header|Crystal}}==

b = gets.not_nil!.to_i64

 

puts "Remainder: #{a % b}" # Sign of remainder matches that of the second operand (b).

puts "Power: #{a ** b}" # Integers can only be raised to a positive exponent.

 

=={{header|D}}==

 

void main() {

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

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

{{out}}

<pre>a = -16, b = 5

===Shorter Version===

Same output.

 

void main() {

foreach (op; AliasSeq!("+", "-", "*", "/", "%", "^^"))

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

$ a = f$integer( a )

$ inquire b "Enter second number"

$ write sys$output "a - b = ", a - b

$ write sys$output "a * b = ", a * b

{{out}}

<pre>$ @arithmetic_integer

 

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

Dyalect has no operator for exponential.

 

let b = 4

print("product = \(a*b)")

print("Integer quotient = \(a/b)")

 

=={{header|E}}==

 

return `$\

Sum: ${a + b}

Quotient: ${a // b}

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

 

=={{header|EasyLang}}==

print a div b

print a mod b

 

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

ELENA 4.x :

import extensions;

 

console.printLine(a," % ",b," = ",a.mod:b); // matches sign of first operand

console.printLine(a," ^ ",b," = ",a ^ b);

 

=={{header|Elixir}}==

{{works with|Elixir|1.4}}

# Function to remove line breaks and convert string to int

defp get_int(msg) do

end

 

 

{{out}}

 

=={{header|Emojicode}}==

🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️ x 💭 Get first number

🍺🔢🆕🔡▶️👂🏼❗ 10❗️ ➡️ y 💭 Get second number

😀 🔤Quotient: 🧲x➗️y🧲🔤 ❗ 💭 Rounds towards 0

😀 🔤Remainder: 🧲x🚮️y🧲🔤 ❗ 💭 Matches sign of first operand

 

=={{header|Erlang}}==

-module(arith).

-export([start/0]).

halt()

end.

 

=={{header|ERRE}}==

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

 

{{out}}

 

For sum, type in C1

=$A1+$B1

 

For difference, type in D1

=$A1-$B1

 

For product, type in E1

=$A1*$B1

 

For quotient, type in F1

=QUOTIENT($A1,$B1)

 

For remainder, type in G1

=MOD($A1,$B1)

 

For exponentiation, type in H1

=$A1^$B1

 

=={{header|F_Sharp|F#}}==

As F# is a functional language, we can easily create a list of pairs of the string name of a function and the function itself to iterate over printing the operation and applying the function to obtain the result:

do

let a, b = int Sys.argv.[1], int Sys.argv.[2]

for str, f in ["+", ( + ); "-", ( - ); "*", ( * ); "/", ( / ); "%", ( % )] do

printf "%d %s %d = %d\n" a str b (f a b)

For example, the output with the arguments 4 and 3 is:

4 + 3 = 7

4 - 3 = 1

4 / 3 = 1

4 % 3 = 1

 

=={{header|Factor}}==

math.parser prettyprint ;

 

[ gcd "gcd: " write . drop ]

[ lcm "lcm: " write . ]

 

{{out}}

 

=={{header|FALSE}}==

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

"sum = "+."

quotient = "/."

modulus = "/*-."

 

=={{header|Fermat}}==

Integer division rounds towards zero; remainders are always positive regardless of the signs of the numbers.

?a;

?b;

!!('Remainder: a|b=',a|b);

!!('Exponentiation: a^b=',a^b);

{{out}}<pre>

>a := 64

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

 

Dim As Integer i, j

 

' Remainder (for which FB uses the Mod operator) will, if non-zero, match the sign

 

Sample input and output:-

 

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

}

 

{{out}}

10 + 20 = 30

10 - 20 = -10

10 mod 20 = 10

10 ^ 20 = 100000000000000000000

 

=={{header|FutureBasic}}==

Basic program

window 1, @"Integer Arithmetic", ( 0, 0, 400, 300 )

 

 

HandleEvents

 

Output:

 

Standalone Intel, M1, M2 Macintosh application with user input

 

_window = 1

 

HandleEvents

 

Output:

 

=={{header|Gambas}}==

Dim a, b As String

Dim c, d As Integer

 

End

Output:

<pre>

 

=={{header|GAP}}==

local a, b, f;

f := InputTextUser();

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

CloseStream(f);

 

=={{header|Genie}}==

Note: Using ''init:int'' and the ''return'' from the init block was introduced in release 0.43.92, February 2019.

 

/*

Arithmethic/Integer, in Genie

print "\nGenie does not include a raise to power operator"

 

 

{{out}}

 

=={{header|GEORGE}}==

R (n) ;

m n + P;

m n × P;

m n div P;

 

=={{header|Go}}==

===int===

 

import "fmt"

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

// no exponentiation operator

{{out|Example run}}

<pre>

</pre>

===big.Int===

 

import (

 

// as with int, no exponentiation operator

{{out|Example run}}

<pre>

=={{header|Groovy}}==

'''Solution:'''

println """

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

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

"""

 

'''Test:'''

 

{{out}}

 

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

a = Str2I64(GetStr("Enter your first number: "));

b = Str2I64(GetStr("Enter your second number: "));

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

Print("a ` b = %d\n", a ` b);

 

=={{header|i}}==

a $= integer(in(' ')); ignore

b $= integer(in('\n')); ignore

print("Modulus:" , a % b) // same sign as first operand

print("Exponent:" , a ^ b)

 

=={{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>calc</code> constructs a list of numeric results for this task. The implementation of integer division we use here (<code><.@%.</code>) rounds down (towards negative infinity), and this is compatible with the remainder implementation we use here.

 

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

 

combine =: ,. ":@,.

bia =: labels combine calc

Quotient: 5

Remainder: 2

 

=={{header|Java}}==

 

public class IntegerArithmetic {

System.out.println("remainder of a / b = " + remainder); // same sign as first operand

}

 

=={{header|JavaScript}}==

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

}

{{out}}

<pre>Enter an integer

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

===Node.JS===

var a = parseInt(process.argv[2], 10);

var b = parseInt(process.argv[3], 10);

console.log('a * b = %d', product);

console.log('a / b = %d', division);

{{out}}

<pre>$ node arith.js 10 7

 

=={{header|jq}}==

 

def arithmetic:

 

arithmetic

{{Out}}

<pre>

 

=={{header|Jsish}}==

/* Arthimetic/Integer, in Jsish */

var line = console.input();

Exponentiation A to the power B is 2401

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

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

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

end

{{Out}}

<pre>julia> arithmetic()

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

println()

}

 

{{out}}

=={{header|Lambdatalk}}==

Translation of Racket

{def arithmetic

{lambda {:x :y}

applying > on 8 & 12 returns false

applying < on 8 & 12 returns true

 

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

write "Enter two numbers separated by space: "

if {[canread]} {set line [readline]}

print "Integer Quotient A \\ B is [expr $a \ $b], truncates toward zero"

print "Remainder A % B is [expr $a % $b], sign follows first operand"

 

{{out}}

 

=={{header|Lingo}}==

x = integer(member("X").text)

y = integer(member("Y").text)

put "Quotient: " , x / y -- Truncated towards zero

put "Remainder: " , x mod y -- Result has sign of left operand

 

=={{header|Little}}==

# from Tcl with:

# eval("namespace path ::tcl::mathfunc");

puts("${a} / ${b} = ${a/b}, remainder ${a%b}");

puts("${a} to the power of ${b} = ${(int)pow(a,b)}");

 

=={{header|LiveCode}}==

if it is not empty then

put item 1 of it into n1

combine ai using comma and colon

put ai

Examples<lang>-2,4 - power:16,product:-8,quotient:0,remainder:-2,sum:2

2,-4 - power:0.0625,product:-8,quotient:0,remainder:2,sum:-2

-2,-4 - power:0.0625,product:8,quotient:0,remainder:-2,sum:-6

2,4 - power:16,product:8,quotient:0,remainder:2,sum:6

 

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

 

 

MODULE LikeCommodoreBasic {

\\ ADDITION: EUCLIDEAN DIV# & MOD# AND ** FOR POWER INCLUDING ^

}

IntegerTypes

 

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

>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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["integer quotient: ", Quotient[a, b]];

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

gives back for input 17 and 3:

<pre>You gave me 17 and 3

 

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

io.set_exit_status(1, !IO)

).

 

=={{header|Metafont}}==

 

message "input number a: ";

s1 := readstring;

outp("mod");

 

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

("Enter an integer" ask int) 2 times ' prepend

{{out}}

<pre>

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

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

 

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

and then output the results to 'standard output' or similar.

 

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

{{trans|Python}}

x = int(input())

print "Number 2: "

 

println format("Remainder: %d", x % y)

 

{{out}}

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

 

options replace format comments java crossref symbols binary

 

return

{{out}}

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

=={{header|NewLISP}}==

 

; oofoe 2012-01-17

 

 

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

 

{{out}}

 

Define new operator using an atlas of operators:

 

Test new operator:

 

Negative divisors are not accepted for integer quotient <code>quotient</code> or remainder <code>mod</code>, and in both cases the result is an error with the message <code>?negative divisor</code>.

Nial definition of <code>quotient</code>:

 

 

<code>floor</code> rounds towards negative infinity (next lower integer).

 

=={{header|Nim}}==

var

echo("a mod b: " & $(a mod b)) # sign(a mod b)==sign(a) if sign(a)!=sign(b)

echo("a ^ b : " & $(a ^ b))

Execute: Aritmint 4 5

{{out}}

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

{{out}}

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

 

"a + b =" . a b + .cr

"a - b =" . a b - .cr

"a mod b =" . a b mod .cr

"a pow b =" . a b pow .cr

 

{{out}}

=={{header|Ol}}==

 

(define a 8)

(define b 12)

(print (* 1 3 5 7 9)) ; same as (1*3*5*7*9)

(print (/ 1 3 5 7 9)) ; same as (((1/3)/5)/7)/9

{{out}}

<pre>

=={{header|Onyx}}==

 

# All you really need to do is push two integers onto the stack

# and then execute add, sub, mul, idiv, or pow.

} bind def

 

 

{{out}}

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

Use reflection to get all functions defined on numbers taking number and returning number.

 

{{out}}

=={{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 = ',Power(a,b):4:2); {real power}

writeln('a^b = ',IntPower(a,b):4:2); {integer power}

 

=={{header|Perl}}==

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

my $b = <>;

 

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

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

 

=={{header|Phix}}==

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/ArithInt.htm here] (layout/space is not perfected yet).

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

<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

With an input of "2 3"

 

=={{header|Phixmonti}}==

swap print print nl

enddef

"int(a / b) = " a b / int printOp

"a mod b = " a b mod printOp

 

=={{header|PHL}}==

 

 

extern printf;

return 0;

 

=={{header|PHP}}==

$a = fgets(STDIN);

$b = fgets(STDIN);

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

"power: ", $a ** $b, "\n"; // PHP 5.6+ only

 

=={{header|Picat}}==

X = read_int(),

Y = read_int(),

printf("%d %w %d = %d\n", X, Op, Y, R)

end.

 

{{out}}

 

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

 

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

Start up.

Demonstrate integer arithmetic.

Divide the number by the other number giving a quotient [rounding toward zero] and a remainder [with the same sign as the dividend].

Write the quotient then " is the quotient." to the console.

{{out}}

<pre>

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

 

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

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

println(a + " / " + b + " = " + (a / b)); //Rounds towards zero

{{out}}

<pre>7 + 5 = 12

 

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

{{out}}

<pre>12 + 8 => 20

 

== Python 3.x Long Form ==

# input1 = input()

input2 = 7

print("Actual Remainder: " + str(uu))

yy = input1 ** input2

 

{{Out}}

=={{header|QB64}}==

''CBTJD'': 2020/03/12

INPUT "Enter two integers (a,b):"; a!, b!

IF a = 0 THEN END

IF UCASE$(a$) = "Y" THEN CLS: GOTO START

CLS

 

=={{header|Quackery}}==

 

input quackery

2dup say "Their sum is: " + echo cr

cr

say "Quotient rounds towards negative infinity." cr

 

{{Out}}

 

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

#lang racket/base

 

 

(arithmetic 8 12)

{{out}}

<pre>

 

Note that <code>div</code> <b>requires</b> integer arguments. If you want integer division with other types, say <code>floor($a/$b)</code>.

my Int $b = get.floor;

 

say 'integer quotient: ', $a div $b;

say 'remainder: ', $a % $b;

 

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

]

 

 

{{out}}

=={{header|Relation}}==

There is no input, variables have to be set in code. Format is there only for output.

set a = -17

set b = 4

echo "a MOD b = ".format(a mod b,"%1d")

echo "a^b = ".format(pow(a,b),"%1d")

 

=={{header|ReScript}}==

 

let b = int_of_string(Sys.argv[3])

 

Js.log("a * b = " ++ string_of_int(product))

Js.log("a / b = " ++ string_of_int(division))

 

{{out}}

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

over '\na_______=_%n s:put

dup '\nb_______=_%n s:put

dup-pair * '\na_*_b___=_%n s:put

/mod '\na_/_b___=_%n s:put

 

=={{header|REXX}}==

For division that produces a floating point number, the result is rounded to the nearest number that can be expressed

<br>within the current number of decimal digits &nbsp; (in the example program below, it is &nbsp; '''20''' &nbsp; decimal digits).

numeric digits 20 /*#s are round at 20th significant dig.*/

parse arg x y . /*maybe the integers are on the C.L. */

exit /*stick a fork in it, we're all done. */

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

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 4 &nbsp; -17 </tt>}}

<pre>

 

=={{header|Ring}}==

func Test a,b

see "a+b" + ( a + b ) + nl

see "a%b" + ( a % b ) + nl

see "a**b" + pow(a,b ) + nl

 

=={{header|Robotic}}==

input string "Enter number 1:"

set "a" to "input"

[ "Remainder: ('a' % 'b')"

[ "Exponentiation: ('a'^'b')"

 

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

 

=={{header|Run BASIC}}==

input "2nd integer: "; i2

if i2 <>0 then print " Quotent "; int( i1 / i2); else print "Cannot divide by zero."

print "Remainder"; i1 MOD i2

 

=={{header|Rust}}==

 

Note that this code cannot be run within the [http://play.rust-lang.org Rust playpen] as it does not support console input.

 

fn main() {

println!("integer quotient: {}", a / b); // truncates towards zero

println!("remainder: {}", a % b); // same sign as first operand

 

=={{header|Sass/SCSS}}==

 

@function arithmetic($a,$b) {

@return $a + $b, $a - $b, $a * $b, ($a - ($a % $b))/$b, $a % $b;

}

Which you use with:

nth(arithmetic(10,3),1);

Or each of the functions separately:

@function sum($a,$b) {

@return $a + $b;

@return $a / $b;

}

 

=={{header|Scala}}==

val b = Console.readInt

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

println("quotient of a / b = " + (a / b)) // truncates towards 0

 

=={{header|Scheme}}==

 

(for-each (lambda (op)

(write (list op x y))

'(+ - * / quotient remainder modulo max min gcd lcm)))

quotient - truncates towards 0

remainder - same sign as first operand

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("a mdiv b = " <& a mdiv b); # Rounds towards negative infinity

writeln("a mod b = " <& a mod b); # Sign of the second operand

 

=={{header|SenseTalk}}==

put it into number1

 

put "Integer quotient: " & number1 div number2 -- Rounding towards 0

put "Remainder: " & number1 rem number2

 

=={{header|Sidef}}==

var b = Sys.scanln("Second number: ").to_i;

 

%w'+ - * // % ** ^ | & << >>'.each { |op|

"#{a} #{op} #{b} = #{a.$op(b)}".say;

 

{{out}}

 

=={{header|Slate}}==

inform: (a + b) printString.

inform: (a - b) printString.

inform: (a \\ b) printString.

 

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

'Input number a: ' display.

a := (stdin nextLine) asInteger.

('a*b=%1' % { a * b }) displayNl.

('a/b=%1' % { a // b }) displayNl.

 

{{works with|Smalltalk/X}} (and all other Smalltalks)

a := (Dialog request:'Enter first number:') asNumber.

b := (Dialog request:'Enter second number:') asNumber.

result := a perform:operator with:b.

'%P %s %P => %P\n' printf:{a . operator . b . result} on:Transcript

/ is exact division

<br>// is truncating division (towards negative infinity)

 

=={{header|smart BASIC}}==

INPUT "Enter second number.":second

PRINT "The sum of";first;"and";second;"is ";first+second&"."

ENDIF

PRINT "The remainder being...";first%second&"."

 

'''NOTES:''' Some curious aspects of smart BASIC to note in this code example:

 

=={{header|SNOBOL4}}==

output = "Enter first integer:"

first = input

output = "rem = " first - (qout * second)

output = "expo = " first ** second

 

=={{header|SNUSP}}==

 

''See also: [[Ethiopian Multiplication]]''

,

@

\=@@@+@+++++#

.

 

=={{header|SQL}}==

{{works with|Oracle}}

-- test.sql

-- Tested in SQL*plus

 

select power(a,b) exponentiation from test;

 

<pre>

=={{header|SSEM}}==

The only operation that the SSEM supports natively is substraction. This program uses the <tt>001 Sub.</tt> instruction to find the difference between <i>a</i> and <i>b</i>, assuming they are loaded into storage addresses 20 and 21 respectively.

10100000000001100000000000000000 1. c to 5

10100000000000100000000000000000 2. -5 to c

10101000000000010000000000000000 3. Sub. 21

00000000000001110000000000000000 4. Stop

The routine is slightly more complicated than it would otherwise be, because the SSEM cannot load a value into the accumulator (<tt>c</tt> register) from storage without negating it in the process—so we have to shuffle the negation of <i>a</i> back out into storage and then negate it again before we can subtract <i>b</i> from it. This does, however, make it easy to implement addition using negation and subtraction. In this program, we first negate <i>a</i>; then subtract <i>b</i>, and store the result; and finally negate that result, thereby obtaining the sum of the two integers.

10101000000000010000000000000000 1. Sub. 21

10100000000001100000000000000000 2. c to 5

10100000000000100000000000000000 3. -5 to c

00000000000001110000000000000000 4. Stop

A multiplication program will be found at [[Function definition#SSEM]], and one that performs integer division at [[Loops/For with a specified step#SSEM]].

 

=={{header|Standard ML}}==

val a = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))

val b = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))

print ("a rem b = " ^ Int.toString (Int.rem (a, b)) ^ "\n"); (* same sign as first operand *)

print ("~a = " ^ Int.toString (~a) ^ "\n") (* unary negation, unusual notation compared to other languages *)

 

=={{header|Swift}}==

let a = 6

let b = 4

print("Remainder = (a%b)")

print("No operator for Exponential")

 

=={{header|Tcl}}==

 

set x [expr {int([gets stdin])}]; # Force integer interpretation

puts "$x / $y = [expr {$x / $y}]"

puts "$x mod $y = [expr {$x % $y}]"

 

Since Tcl doesn't really know about the "type" of a variable, the "<tt>expr</tt>" command is used to declare whatever follows as an "expression". This means there is no such thing as "integer arithmetic" and hence the kludge with <tt>int([gets&nbsp;stdin])</tt>.

Often, these operations would be performed in a different way from what is shown here. For example, to increase the variable "x" by the value of the variable "y", one would write

 

 

Also, it's important to surround the arguments to the <code>expr</code> in braces, especially when any of the parts of the expression are not literal constants. Discussion of this is on [http://wiki.tcl.tk/10225 The Tcler's Wiki].

=={{header|Terraform}}==

HCL doesn't have an exponentiation operator and even integer division is contrived as shown in the code, but at least it prints the output variables alphabetically without any effort.......

#Aamrun, 15th August 2022

 

value = var.a % var.b

}

The floor function rounds to the closest lowest integer. Invocation and output are as below :

{{out}}

=={{header|TI-83 BASIC}}==

Pauses added due to TI-83's lack of screen size.

Prompt A,B

Disp "SUM"

Disp "REMAINDER"

Pause A-B*int(A/B)

 

=={{header|TI-89 BASIC}}==

 

Prompt a, b

Disp "Sum: " & string(a + b)

Disp "Product: " & string(a * b)

Disp "Integer quotient: " & string(intDiv(a, b))

 

=={{header|Toka}}==

 

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

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

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

2dup ." a/b = " / . ." remainder " mod . cr

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

a=5

c=a/b

c=a%b

{{out}}

<pre>

{{works with|Bourne Shell}}

{{works with|Almquist SHell}}

read a; read b;

echo "a+b = " `expr $a + $b`

echo "a*b = " `expr $a \* $b`

echo "a/b = " `expr $a / $b` # truncates towards 0

 

Notes: Using the ` (backtick operators, also available in most Bourne shells via the ''$(...)'' syntax) allows us to keep the results on their labels in the most efficient and portable way. The spaces around the operators in the ''expr'' command line arguments are required and the shell requires us to quote or escape the ''*'' character has shown, to prevent any possible "globbing" --- filename expansion of the ''*'' as a wildcard character.

{{works with|pdksh|5.2.14}}

{{works with|Z SHell}}

read a; read b;

echo "a+b = $((a+b))"

echo "a*b = $((a*b))"

echo "a/b = $((a/b))" # truncates towards 0

 

Note: spaces inside the ''$((...))'' are optional and not required; the ''$((...))'' can be inside or outside the double quotes, but the `...` expressions from the previous example can also be inside or outside the double quotes.

 

=={{header|Ursa}}==

# integer arithmetic

#

out "quot:\t" (int (/ x y)) endl console

# mod takes the sign of x

 

Sample session:

 

=={{header|VBA}}==

'Arithmetic - Integer

Sub RosettaArithmeticInt()

Next opr

End Sub

 

=={{header|VBScript}}==

 

===Implementation===

dim a, b

wscript.stdout.write "A? "

wscript.echo "a \ b=", a \ b

wscript.echo "a mod b=", a mod b

 

===Another Implementation===

Gives the same output for the same input. Inspired by Python version.

dim a, b

wscript.stdout.write "A? "

for each op in split("+ - * / \ mod ^", " ")

wscript.echo "a",op,"b=",eval( "a " & op & " b")

 

===Invocation===

 

=={{header|Vedit macro language}}==

#2 = Get_Num("Give number b: ")

Message("a + b = ") Num_Type(#1 + #2)

Message("a * b = ") Num_Type(#1 * #2)

Message("a / b = ") Num_Type(#1 / #2)

 

 

=={{header|Verilog}}==

integer a, b;

integer suma, resta, producto;

$finish ;

end

 

=={{header|Vim Script}}==

let b = float2nr(input("Number 2: ") + 0)

echo "\nSum: " . (a + b)

" The sign of the result of the remainder operation matches the sign of

" the first operand

 

=={{header|Visual Basic .NET}}==

Module Module1

Sub Main

WriteLine("Exponent " & a ^ b)

End Sub

 

=={{header|Vlang}}==

// Tectonics: v run arithmetic-integer.v

module main

println("no exponentiation operator")

println(" math.pow: pow(a,b) = ${math.pow(a,b)}")

 

{{out}}

 

=={{header|Wart}}==

b <- (read)

prn "sum: " a+b

prn "integer quotient: " (int a/b)

prn "remainder: " a%b

 

=={{header|Wren}}==

 

The sign of the remainder operator '%' matches the sign of the first operand.

System.write("first number: ")

Stdout.flush()

System.print("integer quotient: %((a / b).floor)")

System.print("remainder: %(a % b)")

 

{{out}}

=={{header|x86 Assembly}}==

Input and output would be OS-specific and are not implemented. This routine works on the 16-bit 8086, as well as on its 32-bit and 64-bit successors: it could be trivially modified to perform 32-bit or 64-bit arithmetic on machines where those are supported. The quotient is truncated towards zero; the remainder takes its sign from the first operand.

mov bx, b

xor dx, dx

mov remainder, dx

 

 

=={{header|XLISP}}==

(DISPLAY "Enter two integers separated by a space.")

(NEWLINE)

(DISPLAY `(REMAINDER ,(REM A B))) ; takes sign of first operand

(NEWLINE)

 

=={{header|XPL0}}==

int A, B;

[A:= IntIn(0);

IntOut(0, A/B); CrLf(0); \truncates toward zero

IntOut(0, rem(0)); CrLf(0); \remainder's sign matches first operand (A)

 

=={{header|XSLT}}==

<xsl:param name="a">5</xsl:param>

<xsl:param name="b">2</xsl:param>

<fo:block>a / b = <xsl:value-of select="round($a div $b)"/></fo:block>

<fo:block>a mod b = <xsl:value-of select="$a mod $b"/></fo:block>

 

 

=={{header|Yabasic}}==

input "ingrese otro numero? " b

 

print "modulo ", a, " % ", b, " = ", mod(a, b)

print "potencia ", a, " ^ ", b, " = ", (a ^ b)

 

 

=={{header|Yorick}}==

read, x, y;

write, "x + y =", x + y;

write, "x / y =", x / y; // rounds toward zero

write, "x % y =", x % y; // remainder; matches sign of first operand when operands' signs differ

 

=={{header|zkl}}==

println("x+y = ",x + y);

println("x-y = ",x - y);

println("x/y = ",x / y); // rounds toward zero

println("x%y = ",x % y); // remainder; matches sign of first operand when operands' signs differ

 

=={{header|zonnon}}==

module Main;

var

writeln("remainder: ", i mod j);

end Main.

{{Out}}

<pre>

 

=={{header|ZX Spectrum Basic}}==

10 PRINT a;" + ";b;" = ";a+b

20 PRINT a;" - ";b;" = ";a-b

50 PRINT a;" mod ";b;" = ";a-INT (a/b)*b

60 PRINT a;" to the power of ";b;" = ";a^b