整数除算の商と剰余

整数同士の割り算の，商と剰余についてまとめておく。

私が今まで使ったことのある言語についてのみであるが。
Prorog とか Pascal とか PL/I とかそのほかにもあるが，今となっては実行環境がないので，確かめることができない。

結果を先に述べておく。

2 つの整数を (a, b) とすると，それぞれの符号で 4 通りある。例として，(21, 4), (21, -4), (-21, 4), (-21, -4) でやってみる。

★★★  (商, 剰余) がそれぞれ (5, 1), (-5, 1), (-5, -1), (5, -1) となる言語

AWK, C, C#, C++, COBOL, D, F#, FORTRAN, Go, Java, JavaScript, PHP, Scala, Swift, VB
Haskel で quot() と rem() を使う場合，
Julia で div() と rem() を使う場合，
Perl でゼロ方向への丸めをするようにプログラムする場合

★★  (商, 剰余) がそれぞれ (5, 1), (-6, -3), (-6, 3), (5, -1) となる言語

Python2, Python3, R, Ruby,
Haskel で dif() と mod() を使う場合，
Julia で剰余の計算を a - div(a, b) * b で計算するようにプログラムする場合，
Perl で -∞ 方向への丸めを行い，剰余の計算を a - div(a, b) * b で計算するようにプログラムする場合

★　迂闊にやると，(商, 剰余) がそれぞれ (5, 1), (-5, -3), (-5, 3), (5, -1) となる言語

Julia で div() と mod() を使う場合（誤った選択。div() と rem() を使えば ★★★，剰余の計算を自分ですれば ★★）
Perl で int($a / $b), と $a % $b を使う場合（適切にプログラムして ★★★ にするか ★★ にする）
このような場合，「 a = 商 * b + 剰余」が成り立たないので，不適切な解となってしまう。

========= AWK

BEGIN {
    OFS = ", "
    a = 21
    b = 4
    print int(a / b), a % b
}

========= C

#include
#include

int main(int argc, char **argv) {
    int a = 21;
    int b = 4;
    printf("%d, %d\n", a / b, a % b);
    return EXIT_SUCCESS;
}

========= C#

public class Hello{
    public static void Main(){
        int a, b;
        a = 21;
        b = 4;
        System.Console.WriteLine(a / b + ", " + a % b);
    }
}

========= C++

#include

int main(int argc, char **argv) {
    int a = 21;
    int b = 4;
    std::cout <
    return EXIT_SUCCESS;
}

========= COBOL

identification division.
program-id. Hello.
data division.
working-storage section.
01 working-area.
    02 x pic s9.
    02 y pic s9.
procedure division.
divide 21 by 4 giving x remainder y.
display x, ",  ", y.

========= D

import std.stdio;
void main() {
    int a, b;
    a = 21;
    b = 4;
    writeln(a / b, ", ", a % b);
}

========= F#

let a = 21;;
let b = 4;;
printfn "%d, %d" (a / b) (a % b);;

========= Fortran

program main
 implicit none
 integer a, b
 a = -21
 b = -4
 write(*, *) int(a / b), ", ", mod(a, b)
end program main

========= Go

package main
import "fmt"
func main() {
    var a int = 21
    var b int = 4
    fmt.Printf("%d, %d", a / b, a % b)
}

========= Java

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        int a = 21;
        int b = 4;
        System.out.println(a / b + ", " + a % b);
    }
}

========= JavaScript

var a = 21;
var b = 4;
var x = a / b;
// 一律に Math.floor を紹介するページが多いが，a, b の符号が違うときには誤った答えになるので注意
x = x < 0 ? Math.ceil(x) : Math.floor(x)
console.log(x + ", " + a % b);

========= PHP

$a = 21;
$b = 4;
echo (int)($a / $b), ", ", $a % $b;
?>

========= Scala

object Main extends App {
    var a = 21
    var b = 4
    println(a / b + ", " + a % b)
}

========= Swift

var a:Int = -23
var b:Int = 4
print("\(a / b), \(a % b)")

========= VB VisualBasic

public class compiler
  shared function Main as integer
    Dim a As Integer: a = -23
    Dim b As Integer: b = 4
    ' int() は -∞方向への丸めなので不適切
    Console.WriteLine(fix(a / b) & ", " & a Mod b)
    return 0
  end function
end class

###############################################

========= Julia

a = 21
b = 4
# ハイブリッド（不適切な実装）
println(div(a, b), ", ", mod(a,b))
# ゼロ方向へ丸め（C などと同じ多数派）
println(div(a, b), ", ", rem(a,b))
# -∞方向へ丸め（Python などと同じだが少数派）
x = div(a, b)
println(x, a - x * b)

========= Perl

$a = 21;
$b = 4;
# ハイブリッド（不適切な実装）
print int($a / $b), ', ', $a % $b;
# ゼロ方向へ丸め（C などと同じ多数派）
print int($a / $b), ', ', $a - int($a / $b) * $b;
# -∞方向へ丸め（Python などと同じだが少数派）
$x = $a / $b
$x = int($x) - $x < 0 ? 1 : 0 
print $x, ', ', $a - $x * b;

###############################################

========= Haskell

main = do
    let a = 21
    let b = 4
    -- ゼロ方向へ丸め（C などと同じ多数派）
    putStrLn $ show(a `quot` b) ++ ", " ++ show(a `rem` b)
    -- -∞方向へ丸め（Python などと同じだが少数派）
    putStrLn $ show(a `div` b) ++ ", " ++ show(a `mod` b)

========= Python2

a = 21
b = 4
# -∞方向へ丸め（少数派）
print "%d, %d" % (a // b, a % b)

========= Python3

a = 21
b = 4
# -∞方向へ丸め（少数派）
print("%d, %d" % (a // b, a % b))

========= R

a = 21
b = 4
# -∞方向へ丸め（少数派）
cat(sprintf("%d, %d\n", a %/% b, a %% b))

========= Ruby

$a = 21
$b = 4
# -∞方向へ丸め（少数派）
print $a / $b, ', ', $a % $b