Arithmetic/Integer: Difference between revisions
(don't use EVAL) |
(→{{header|J}}: Add exponentiation and example output, fix remainder, fix tacit definition order) |
||
Line 409: | Line 409: | ||
=={{header|J}}== |
=={{header|J}}== |
||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
combine =: [ ,. ":@|:@,:@] |
|||
⚫ | |||
⚫ | |||
Note that the verb <tt>calc</tt> produces all the processing specified for this problem, and that its output is of numeric type. |
Note that the verb <tt>calc</tt> produces all the processing specified for this problem, and that its output is of numeric type. |
||
17 calc 3 |
|||
20 14 51 5 2 4913 |
|||
Since other examples here provide textual output, <tt>bia</tt> produces like results. |
|||
17 bia 3 |
|||
Sum: 20 |
|||
Difference: 14 |
|||
Product: 51 |
|||
Quotient: 5 |
|||
Remainder: 2 |
|||
Exponentiation: 4913 |
|||
=={{header|Java}}== |
=={{header|Java}}== |
Revision as of 03:41, 27 August 2009
You are encouraged to solve this task according to the task description, using any language you may know.
Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.
You may see other such operations in the Basic Data Operations category, or:
Integer Operations
Arithmetic |
Comparison
Boolean Operations
Bitwise |
Logical
String Operations
Concatenation |
Interpolation |
Comparison |
Matching
Memory Operations
Pointers & references |
Addresses
Get two integers from the user, and then output the sum, difference, product, integer quotient and remainder of those numbers. Don't include error handling. For quotient, indicate how it truncates (e.g. towards 0, towards negative infinity, etc.). For remainder, indicate whether its sign matches the sign of the first operand or of the second operand, if they are different.
Also include the exponentiation operator if one exists.
Ada
<lang ada>with Ada.Text_Io; with Ada.Integer_Text_IO;
procedure Integer_Arithmetic is
use Ada.Text_IO; use Ada.Integer_Text_Io;
A, B : Integer;
begin
Get(A); Get(B); Put_Line("a+b = " & Integer'Image(A + B)); Put_Line("a-b = " & Integer'Image(A - B)); Put_Line("a*b = " & Integer'Image(A * B)); Put_Line("a/b = " & Integer'Image(A / B) & ", remainder " & Integer'Image(A mod B)); Put_Line("a**b = " & Integer'Image(A ** B));
end Integer_Arithmetic;</lang>
ALGOL 68
main:( LONG INT a=355, b=113; printf(($"a+b = "gl$, a + b)); printf(($"a-b = "gl$, a - b)); printf(($"a*b = a×b = "gl$, a * b)); printf(($"a/b = "gl$, a / b)); 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)) )
Output:
a+b = +468a-b = +242 a*b = a×b = +40115 a/b = +3.141592920353982300884955752e +0 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
ALGOL 68R has the curious (and consequently non-standard) /:= operator. This operator delivers two INTs as a result. eg.
INT quotient:=355, remainder; remainder := quotient /:= 113;
Giving a quotient of 3, and a remainder of 16.
AmigaE
<lang amigae>PROC main()
DEF a, b, t WriteF('A = ') ReadStr(stdin, t) a := Val(t) WriteF('B = ') ReadStr(stdin, t) b := Val(t) WriteF('A+B=\d\nA-B=\d\n', a+b, a-b) WriteF('A*B=\d\nA/B=\d\n', a*b, a/b) /* * and / are 16 bit ops; Mul and Div are 32bit ops */ WriteF('A*B=\d\nA/B=\d\n', Mul(a,b), Div(a,b)) WriteF('A mod B =\d\n', Mod(a,b))
ENDPROC</lang>
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). <lang autohotkey>Gui, Add, Edit, va, 5 Gui, Add, Edit, vb, -3 Gui, Add, Button, Default, Compute Gui, Show Return
ButtonCompute:
Gui, Submit MsgBox,% (Join`s"`n" a "+" b " = " a+b a "-" b " = " a-b a "*" b " = " a*b a "//" b " = " a//b " remainder " Mod(a,b) a "**" b " = " a**b )
- fallthrough
GuiClose:
ExitApp</lang>
AWK
/[0-9]* [0-9]*/{ print ($1 + $2) print ($1 - $2) print ($1 * $2) print int($1 / $2) print ($1 % $2) exit}
BASIC
<lang qbasic>function math(a!, b!) print a + b print a - b print a * b print a / b print a mod b end function</lang> Truncate towards: 0
Remainder sign matches: first operand
Befunge
&&00p"=A",,:."=B ",,,00g.55+,v v,+55.+g00:,,,,"A+B="< >"=B-A",,,,:00g-.55+,v v,+55.*g00:,,,,"A*B="< >"=B/A",,,,:00g/.55+,v @,+55.%g00,,,,"A%B="<
C
<lang c>#include <stdio.h>
- include <stdlib.h>
int main(int argc, char *argv[]) {
int a, b; if (argc < 3) exit(1); b = atoi(argv[--argc]); if (b == 0) exit(2); a = atoi(argv[--argc]); printf("a+b = %d\n", a+b); printf("a-b = %d\n", a-b); printf("a*b = %d\n", a*b); printf("a/b = %d\n", a/b); /* truncates towards 0 (in C99) */ printf("a%%b = %d\n", a%b); /* same sign as first operand (in C99) */ return 0;
}</lang>
C++
<lang cpp>#include <iostream>
int main() {
int a, b; std::cin >> a >> b; std::cout << "a+b = " << a+b << "\n"; std::cout << "a-b = " << a-b << "\n"; std::cout << "a*b = " << a*b << "\n"; std::cout << "a/b = " << a/b << ", remainder " << a%b << "\n"; return 0;
}</lang>
C#
<lang csharp>using System;
class Program {
static void Main(string[] args) { if (args.Length < 2) return;
int a = Convert.ToInt32(args[0]); int b = Convert.ToInt32(args[1]);
Console.WriteLine("a - b = {0}", a - b); Console.WriteLine("a * b = {0}", a * b); if (b != 0) { Console.WriteLine("a / b = {0}", a / b); Console.WriteLine("a % b = {0}", a % b); } Console.WriteLine("a to the power of b = {0}", Math.Pow(a, b)(; }
}</lang>
Common Lisp
<lang lisp>(defun arithmetic (&optional (a (read *query-io*)) (b (read *query-io*)))
(mapc (lambda (op) (format t "~a => ~a~%" (list op a b) (funcall (symbol-function op) a b))) '(+ - * mod rem floor ceiling truncate round expt)) (values))</lang>
Common Lisp's integer division functions are floor
, ceiling
, truncate
, and round
. They differ in how they round their quotient.
The function | rounds its quotient towards |
---|---|
floor
|
negative infinity |
ceiling
|
positive infinity |
truncate
|
zero |
round
|
the nearest integer (preferring the even integer if the mathematical quotient is equidistant from two integers) |
Each function also returns a remainder as its secondary value, such that
quotient * divisor + remainder = dividend .
(mod a b)
and (rem a b)
return numbers equal to the secondary values of (floor a b)
and (truncate a b)
, respectively.
D
<lang d>import std.stdio, std.string;
void main() {
auto a = readln().atoi(), b = readln().atoi(); writefln("a + b = ", a+b); writefln("a - b = ", a-b); writefln("a * b = ", a*b); writefln("a / b = ", a/b); writefln("a % b = ", a%b);
}</lang>
DOS Batch File
@set /P A=Enter 1st Number : @set /P B=Enter 2nd Number : @set D=%A% + %B% & call :printC @set D=%A% - %B% & call :printC @set D=%A% * %B% & call :printC @set D=%A% / %B% & call :printC @set D=%A% %% %B% :printC @set /A C=%D% @echo %D% = %C%
E
def arithmetic(a :int, b :int) { return `$\ Sum: ${a + b} Difference: ${a - b} Product: ${a * b} Quotient: ${a // b} Remainder: ${a % b}$\n` }
Factor
USING: combinators io kernel math math.functions math.order math.parser prettyprint ; "a=" "b=" [ write readln string>number ] bi@ { [ + "sum: " write . ] [ - "difference: " write . ] [ * "product: " write . ] [ / "quotient: " write . ] [ /i "integer quotient: " write . ] [ rem "remainder: " write . ] [ mod "modulo: " write . ] [ max "maximum: " write . ] [ min "minimum: " write . ] [ gcd "gcd: " write . drop ] [ lcm "lcm: " write . ] } 2cleave
output:
a=8 b=12 sum: 20 difference: -4 product: 96 quotient: 2/3 integer quotient: 0 remainder: 8 modulo: 8 maximum: 12 minimum: 8 gcd: 4 lcm: 24
This example illustrates the use of cleave and apply combinators to alleviate the usage of shuffle words in a concatenative language. bi@ applies a quotation to 2 inputs and 2cleave applies a sequence of quotations to 2 inputs.
FALSE
12 7 \$@$@$@$@$@$@$@$@$@$@\ { 6 copies } "sum = "+." difference = "-." product = "*." quotient = "/." modulus = "/*-." "
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 ).
: arithmetic ( a b -- ) cr ." a=" over . ." b=" dup . cr ." a+b=" 2dup + . cr ." a-b=" 2dup - . cr ." a*b=" 2dup * . cr ." a/b=" /mod . cr ." a mod b = " . cr ;
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.
FM/MOD ( d n -- mod div ) \ floored SM/REM ( d n -- rem div ) \ symmetric M* ( n n -- d )
In addition, there are unsigned variants.
UM/MOD ( ud u -- umod udiv ) UM* ( u u -- ud )
Fortran
In ANSI FORTRAN 77 or later:
INTEGER A, B PRINT *, 'Type in two integer numbers separated by white space', + ' and press ENTER' READ *, A, B PRINT *, ' A + B = ', (A + B) PRINT *, ' A - B = ', (A - B) PRINT *, ' A * B = ', (A * B) PRINT *, ' A / B = ', (A / B) PRINT *, 'MOD(A,B) = ', MOD(A,B) PRINT * PRINT *, 'Even though you did not ask, ', + 'exponentiation is an intrinsic op in Fortran, so...' PRINT *, ' A ** B = ', (A ** B) END
F#
#light [<EntryPoint>] let main args = if Array.length args <> 2 then eprintfn "usage: basic_arithmethic numA numB" exit 0 let (j, a) = System.Int32.TryParse(args.[0]) let (k, b) = System.Int32.TryParse(args.[1]) printfn "a add b = %d" (a + b) printfn "a subtract b = %d" (a - b) printfn "a multiplied by b = %d" (a * b) printfn "a divided by b = %d" (a / b) printfn "a mod b = %d" (a % b) 0
Groovy
<lang groovy>def arithmetic = { a, b ->
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} !!!
(int)(a / b) = (int)(${a} / ${b}) = ${(int)(a / b)} !!!
a.intdiv(b) = ${a}.intdiv(${b}) = ${a.intdiv(b)} !!! a % b = ${a} % ${b} = ${a % b}
Exponentiation is also a base arithmetic operation in Groovy, so:
a ** b = ${a} ** ${b} = ${a ** b}
""" }</lang>
Program: <lang groovy>arithmetic(5,3)</lang>
Output:
a + b = 5 + 3 = 8 a - b = 5 - 3 = 2 a * b = 5 * 3 = 15 a / b = 5 / 3 = 1.6666666667 !!! (int)(a / b) = (int)(5 / 3) = 1 !!! a.intdiv(b) = 5.intdiv(3) = 1 !!! a % b = 5 % 3 = 2 Exponentiation is also a base arithmetic operation in Groovy, so: a ** b = 5 ** 3 = 125
Haskell
main = do a <- readLn :: IO Integer b <- readLn :: IO Integer putStrLn $ "a + b = " ++ show (a + b) putStrLn $ "a - b = " ++ show (a - b) putStrLn $ "a * b = " ++ show (a * b) putStrLn $ "a to the power of b = " ++ show (a ** b) putStrLn $ "a to the power of b = " ++ show (a ^ b) putStrLn $ "a to the power of b = " ++ show (a ^^ b) putStrLn $ "a `div` b = " ++ show (a `div` b) -- truncates towards negative infinity putStrLn $ "a `mod` b = " ++ show (a `mod` b) -- same sign as second operand putStrLn $ "a `quot` b = " ++ show (a `quot` b) -- truncates towards 0 putStrLn $ "a `rem` b = " ++ show (a `rem` b) -- same sign as first operand
haXe
Compile on Neko with <lang>haxe -neko basic_integer_arithmetic.n -main BasicIntegerArithmetic</lang>
<lang haxe> class BasicIntegerArithmetic {
public static function main() { var args = neko.Sys.args(); if (args.length < 2) neko.Sys.exit(0); var a = Std.int(args[0]); var b = Std.int(args[1]); trace("a+b = " + (a+b)); trace("a-b = " + (a-b)); trace("a*b = " + (a*b)); trace("a/b = " + (a/b)); trace("a%b = " + (a%b)); }
} </lang>
J
calc =: + , - , * , <.@% , |~ , ^ labels =: >;.2 'Sum: Difference: Product: Quotient: Remainder: Exponentiation: ' combine =: [ ,. ":@|:@,:@] bia =: labels combine calc
Note that the verb calc produces all the processing specified for this problem, and that its output is of numeric type.
17 calc 3 20 14 51 5 2 4913
Since other examples here provide textual output, bia produces like results.
17 bia 3 Sum: 20 Difference: 14 Product: 51 Quotient: 5 Remainder: 2 Exponentiation: 4913
Java
<lang java>import java.util.Scanner;
public static void main(String[] args){
Scanner sc = new Scanner(System.in); int a = sc.nextInt(); int b = sc.nextInt(); int sum = a + b;//integer addition is discouraged in print statements due to confusion with String concatenation System.out.println("a + b = " + sum); System.out.println("a - b = " + (a - b)); System.out.println("a * b = " + (a * b)); System.out.println("quotient of a / b = " + (a / b)); // truncates towards 0 System.out.println("remainder of a / b = " + (a % b)); // same sign as first operand
}</lang>
Logo
to operate :a :b (print [a =] :a) (print [b =] :b) (print [a + b =] :a + :b) (print [a - b =] :a - :b) (print [a * b =] :a * :b) (print [a / b =] int :a / :b) (print [a mod b =] modulo :a :b) end
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.
LSE64
over : 2 pick 2dup : over over arithmetic : \ " A=" ,t over , sp " B=" ,t dup , nl \ " A+B=" ,t 2dup + , nl \ " A-B=" ,t 2dup - , nl \ " A*B=" ,t 2dup * , nl \ " A/B=" ,t 2dup / , nl \ " A%B=" ,t % , nl
M4
Because of the particular nature of M4, the only user-input is the code itself. Anyway the following code can be used: <lang m4>eval(A+B) eval(A-B) eval(A*B) eval(A/B) eval(A%B)</lang>
once saved in a file, e.g. operations.m4:
m4 -DA=4 -DB=6 operations.m4
or using a sort of driver:
<lang m4>define(`A', 4)dnl define(`B', 6)dnl include(`operations.m4')</lang>
Mathematica
Mathematica has all the function built-in to handle this task. Example: <lang Mathematica>
a = Input["Give me an integer please!"]; b = Input["Give me another integer please!"]; Print["You gave me ", a, " and ", b]; Print["sum: ", a + b]; Print["difference: ", a - b]; Print["product: ", a b]; Print["integer quotient: ", IntegerPart[a/b]]; Print["remainder: ", Mod[a, b]]; Print["exponentiation: ", a^b];
</lang> gives back for input 17 and 3: <lang Mathematica>
You gave me 17 and 3 sum: 20 difference: 14 product: 51 integer quotient: 5 remainder: 2 exponentiation: 4913
</lang>
MAXScript
x = getKBValue prompt:"First number" y = getKBValue prompt:"Second number:" format "Sum: %\n" (x + y) format "Difference: %\n" (x - y) format "Product: %\n" (x * y) format "Quotient: %\n" (x / y) format "Remainder: %\n" (mod x y)
Metafont
<lang metafont>string s[]; message "input number a: "; s1 := readstring; message "input number b: "; s2 := readstring; a := scantokens s1; b := scantokens s2;
def outp(expr op) =
message "a " & op & " b = " & decimal(a scantokens(op) b) enddef;
outp("+"); outp("-"); outp("*"); outp("div"); outp("mod");
end</lang>
Modula-3
<lang modula3>MODULE Arith EXPORTS Main;
IMPORT IO, Fmt;
VAR a, b: INTEGER;
BEGIN
a := IO.GetInt(); b := IO.GetInt(); IO.Put("a+b = " & Fmt.Int(a + b) & "\n"); IO.Put("a-b = " & Fmt.Int(a - b) & "\n"); IO.Put("a*b = " & Fmt.Int(a * b) & "\n"); IO.Put("a DIV b = " & Fmt.Int(a DIV b) & "\n"); IO.Put("a MOD b = " & Fmt.Int(a MOD b) & "\n");
END Arith.</lang>
OCaml
<lang ocaml>let _ =
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); Printf.printf "a * b = %d\n" (a * b); Printf.printf "a / b = %d\n" (a / b); (* truncates towards 0 *) Printf.printf "a mod b = %d\n" (a mod b) (* same sign as first operand *)</lang> Printf.printf "a ** b = %d\n" (a ** b);
Octave
<lang octave>disp("integer a: "); a = scanf("%d", 1); disp("integer b: "); b = scanf("%d", 1); a+b a-b a*b floor(a/b) mod(a,b)</lang>
Pascal
<lang pascal> program arithmetic(input, output)
var a, b: integer; begin readln(a, b); writeln('a+b = ', a+b); writeln('a-b = ', a-b); writeln('a*b = ', a*b); writeln('a/b = ', a div b, ', remainder ", a mod b); end.</lang>
Perl
<lang perl>my $a = <>; my $b = <>;
"sum: ", $a + $b, "\n", "difference: ", $a - $b, "\n", "product: ", $a * $b, "\n", "integer quotient: ", int($a / $b), "\n", "remainder: ", $a % $b, "\n", "exponent: ", $a ** $b, "\n" ;</lang>
PHP
<lang php><?php $a = fgets(STDIN); $b = fgets(STDIN);
echo
"sum: ", $a + $b, "\n", "difference: ", $a - $b, "\n", "product: ", $a * $b, "\n", "truncating quotient: ", (int)($a / $b), "\n", "flooring quotient: ", floor($a / $b), "\n", "remainder: ", $a % $b, "\n";
?></lang>
Pop11
;;; Setup token reader vars itemrep; incharitem(charin) -> itemrep; ;;; read the numbers lvars a = itemrep(), b = itemrep(); ;;; Print results printf(a + b, 'a + b = %p\n'); printf(a - b, 'a - b = %p\n'); printf(a * b, 'a * b = %p\n'); printf(a div b, 'a div b = %p\n'); printf(a mod b, 'a mod b = %p\n');
Python
<lang python>x = int(raw_input("Number 1: ")) y = int(raw_input("Number 2: "))
print "Sum: %d" % (x + y) print "Difference: %d" % (x - y) print "Product: %d" % (x * y) print "Quotient: %d" % (x / y) # or x // y for newer python versions.
# truncates towards negative infinity
print "Remainder: %d" % (x % y) # same sign as second operand
- Only used to keep the display up when the program ends
raw_input( )</lang>
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:
<lang python> def getnum(prompt):
while True: # retrying ... try: n = int(raw_input(prompt)) except ValueError: print "Input could not be parsed as an integer. Please try again."\ continue break return n
x = getnum("Number1: ") y = getnum("Number2: ") ... </lang>
(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 also has the procedure divmod that returns both quotient and remainder. eg
quotient, remainder = divmod(355,113)
Giving a quotient of 3, and a remainder of 16.
Python 3.0 compatible code
<lang python>def arithmetic(x, y):
for op in "+ - * // %".split(): expr = "%(x)s %(op)s %(y)s" % vars() print("%s\t=> %s" % (expr, eval(expr)))
arithmetic(12, 8)
arithmetic(input("Number 1: "), input("Number 2: "))</lang>
Output:
12 + 8 => 20 12 - 8 => 4 12 * 8 => 96 12 // 8 => 1 12 % 8 => 4 Number 1: 20 Number 2: 4 20 + 4 => 24 20 - 4 => 16 20 * 4 => 80 20 // 4 => 5 20 % 4 => 0
R
<lang R>cat("insert number ") a <- scan(nmax=1, quiet=TRUE) cat("insert number ") b <- scan(nmax=1, quiet=TRUE) print(a+b) print(a-b) print(a*b) print(floor(a/b)) print(a%%b)</lang>
Raven
<lang raven> ' Number 1: ' print expect 0 prefer as x
' Number 2: ' print expect 0 prefer as y x y + " sum: %d\n" print x y - "difference: %d\n" print x y * " product: %d\n" print x y / " quotient: %d\n" print x y % " remainder: %d\n" print</lang>
Ruby
<lang ruby>puts 'Enter x and y' x=gets.to_i y=gets.to_i
puts "Sum: #{x+y}",
"Difference: #{x-y}", "Product: #{x*y}", "Quotient: #{x/y}", # truncates towards negative infinity "Remainder: #{x%y}" # same sign as second operand</lang>
Scheme
<lang scheme>(define (arithmetic x y)
(for-each (lambda (op) (write (list op x y)) (display " => ") (write ((eval op) x y)) (write-char #\newline)) '(+ - * / quotient remainder modulo max min gcd lcm)))
(arithmetic 8 12)</lang> quotient - truncates towards 0 remainder - same sign as first operand modulo - same sign as second operand
prints this: (+ 8 12) => 20 (- 8 12) => -4 (* 8 12) => 96 (/ 8 12) => 2/3 (quotient 8 12) => 0 (remainder 8 12) => 8 (modulo 8 12) => 8 (max 8 12) => 12 (min 8 12) => 8 (gcd 8 12) => 4 (lcm 8 12) => 24
Slate
<lang slate>
[| :a :b | inform: (a + b) printString. inform: (a - b) printString. inform: (a * b) printString. inform: (a / b) printString. inform: (a // b) printString. inform: (a \\ b) printString.
] applyTo: {Integer readFrom: (query: 'Enter a: '). Integer readFrom: (query: 'Enter b: ')}.
</lang>
Smalltalk
<lang smalltalk>| a b | 'Input number a: ' display. a := (stdin nextLine) asInteger. 'Input number b: ' display. b := (stdin nextLine) asInteger. ('a+b=%1' % { a + b }) displayNl. ('a-b=%1' % { a - b }) displayNl. ('a*b=%1' % { a * b }) displayNl. ('a/b=%1' % { a // b }) displayNl. ('a%%b=%1' % { a \\ b }) displayNl.</lang>
Standard ML
<lang sml>val () = let
val a = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn))) val b = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn)))
in
print ("a + b = " ^ Int.toString (a + b) ^ "\n"); print ("a - b = " ^ Int.toString (a - b) ^ "\n"); print ("a * b = " ^ Int.toString (a * b) ^ "\n"); print ("a div b = " ^ Int.toString (a div b) ^ "\n"); (* truncates towards negative infinity *) print ("a mod b = " ^ Int.toString (a mod b) ^ "\n"); (* same sign as second operand *) print ("a quot b = " ^ Int.toString (Int.quot (a, b)) ^ "\n");(* truncates towards 0 *) 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 *)
end</lang>
SNUSP
As a BF derivative, SNUSP only has increment and decrement as native operations. Here are routines for other basic arithmetic upon single digit numbers and results. <lang SNUSP> $\
, @ \=@@@-@-----# atoi > , @ \=@@@-@-----# < @ # 4 copies \=!/?!/->>+>>+>>+>>+<<<<<<<<?\# > | #\?<<<<<<<<+>>+>>+>>+>>-/ @ | \==/ \>>>>\ />>>>/ @ \==!/===?\# add < \>+<-/ @ \=@@@+@+++++# itoa . < @ \==!/===?\# subtract < \>-<-/ @ \=@@@+@+++++# . ! /\ ?- multiply \/ #/?<<+>+>-==\ /==-<+<+>>?\# /==-<<+>>?\# < \->+>+<<!/?/# #\?\!>>+<+<-/ #\?\!>>+<<-/ @ /==|=========|=====\ /-\ | \======<?!/>@/<-?!\>>>@/<<<-?\=>!\?/>!/@/<# < \=======|==========/ /-\ | @ \done======>>>!\?/<=/ \=@@@+@+++++# . ! /\ ?- zero \/ < divmod @ /-\ \?\<!\?/#!===+<<<\ /-\ | \<==@\>@\>>!/?!/=<?\>!\?/<<# | | | #\->->+</ | \=!\=?!/->>+<<?\# @ #\?<<+>>-/ \=@@@+@+++++# . < @ \=@@@+@+++++# . #
</lang>
Tcl
<lang tcl>puts "Please enter two numbers:"
set x [expr {int([gets stdin])}]; # Force integer interpretation set y [expr {int([gets stdin])}]; # Force integer interpretation
puts "$x + $y = [expr {$x + $y}]" puts "$x - $y = [expr {$x - $y}]" puts "$x * $y = [expr {$x * $y}]" puts "$x / $y = [expr {$x / $y}]" puts "$x mod $y = [expr {$x % $y}]" puts "$x 'to the' $y = [expr {$x ** $y}]"</lang>
Since Tcl doesn't really know about the "type" of a variable, the "expr" 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 int([gets stdin]).
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
<lang tcl>incr x $y</lang>
Also, it's important to surround the arguments to the expr
in braces, especially when any of the parts of the expression are not literal constants. Discussion of this is on The Tcler's Wiki.
TI-89 BASIC
Local a, b Prompt a, b Disp "Sum: " & string(a + b) Disp "Difference: " & string(a - b) Disp "Product: " & string(a * b) Disp "Integer quotient: " & string(intDiv(a, b)) Disp "Remainder: " & string(remain(a, b))
Toka
[ ( a b -- ) 2dup ." a+b = " + . cr 2dup ." a-b = " - . cr 2dup ." a*b = " * . cr 2dup ." a/b = " / . ." remainder " mod . cr ] is mathops
UNIX Shell
With external utilities:
#!/bin/sh read a; read b; echo "a+b = " `expr $a + $b` echo "a-b = " `expr $a - $b` echo "a*b = " `expr $a \* $b` echo "a/b = " `expr $a / $b` # truncates towards 0 echo "a mod b = " `expr $a % $b` # same sign as first operand
(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.
With SUSv3 parameter expansions:
#!/bin/sh read a; read b; echo "a+b = $(($a+$b))" echo "a-b = $(($a-$b))" echo "a*b = $(($a*$b))" echo "a/b = $(($a/$b))" # truncates towards 0 echo "a mod b = $(($a%$b))" # same sign as first operand
(Note: spaces inside the $((...)) are optional and not required; the $((...)) expressions can be inside the double quotes, but the `...` expressions could also have been enclosed in the double quotes in the previous example).
Vedit macro language
#1 = Get_Num("Give number a: ") #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) Message("a / b = ") Num_Type(#1 / #2) Message("a % b = ") Num_Type(#1 % #2)
Visual Basic .NET
Imports System.Console Module Module1 Sub Main Dim a = CInt(ReadLine) Dim b = CInt(ReadLine) WriteLine("Sum " & a + b) WriteLine("Difference " & a - b) WriteLine("Product " & a - b) WriteLine("Quotient " & a / b) WriteLine("Integer Quotient " & a \ b) WriteLine("Remainder " & a Mod b) WriteLine("Exponent " & a ^ b) End Sub End Module
XSLT
<xsl:template name="arithmetic"> <xsl:param name="a">5</xsl:param> <xsl:param name="b">2</xsl:param> <fo:block>a + b = <xsl:value-of select="$a + $b"/></fo:block> <fo:block>a - b = <xsl:value-of select="$a - $b"/></fo:block> <fo:block>a * b = <xsl:value-of select="$a * $b"/></fo:block> <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> </xsl:template>
- Programming Tasks
- Basic language learning
- Arithmetic operations
- Basic Data Operations
- Ada
- ALGOL 68
- AmigaE
- AutoHotkey
- AWK
- BASIC
- Befunge
- C
- C++
- C sharp
- Common Lisp
- D
- DOS Batch File
- E
- Factor
- FALSE
- Forth
- Fortran
- F Sharp
- Groovy
- Haskell
- HaXe
- J
- Java
- Logo
- LSE64
- M4
- Mathematica
- MAXScript
- Metafont
- Modula-3
- OCaml
- Octave
- Pascal
- Perl
- PHP
- Pop11
- Python
- R
- Raven
- Ruby
- Scheme
- Slate
- Smalltalk
- Standard ML
- SNUSP
- Tcl
- TI-89 BASIC
- Toka
- UNIX Shell
- Vedit macro language
- Visual Basic .NET
- XSLT