1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
|
discard """
errormsg: "type mismatch"
line: 116
"""
# bug #2169
import strutils, math
type
Point2D*[S] = object
x*, y*: S
Matrix2x3*[S] = distinct array[6, S] ## Row major order
Vector2D*[S] = object
x*, y*: S
proc `[]`*[T](m: Matrix2x3[T], i: int): T = array[6, T](m)[i]
template M11*[T](m: Matrix2x3[T]): T = m[0]
template M12*[T](m: Matrix2x3[T]): T = m[1]
template M13*[T](m: Matrix2x3[T]): T = m[2]
template M21*[T](m: Matrix2x3[T]): T = m[3]
template M22*[T](m: Matrix2x3[T]): T = m[4]
template M23*[T](m: Matrix2x3[T]): T = m[5]
proc identity*[T](): Matrix2x3[T] =
Matrix2x3[T]([T(1.0), 0.0, 0.0, 0.0, 1.0, 0.0])
proc translation*[T](p: Point2D[T]): Matrix2x3[T] =
Matrix2x3[T]([T(1.0), T(0.0), p.x, T(0.0), T(1.0), p.y])
proc translation*[T](p: Vector2D[T]): Matrix2x3[T] =
Matrix2x3[T]([T(1.0), T(0.0), p.x, T(0.0), T(1.0), p.y])
proc scale*[T](v: Vector2D[T]): Matrix2x3[T] =
Matrix2x3[T]([v.x, T(0.0), T(0.0), T(0.0), v.y, T(0.0)])
proc rotation*[T](th: T): Matrix2x3[T] =
let
c = T(cos(th.float))
s = T(sin(th.float))
Matrix2x3[T]([c, -s, T(0.0), s, c, T(0.0)])
proc `*`*[T](a, b: Matrix2x3[T]): Matrix2x3[T] =
# Here we pretend that row 3 is [0,0,0,1] without
# actually storing it in the matrix.
Matrix2x3[T]([a.M11*b.M11 + a.M12*b.M21,
a.M11*b.M12 + a.M12*b.M22,
a.M11*b.M13 + a.M12*b.M23 + a.M13,
a.M21*b.M11 + a.M22*b.M21,
a.M21*b.M12 + a.M22*b.M22,
a.M21*b.M13 + a.M22*b.M23 + a.M23])
proc `*`*[T](a: Matrix2x3[T], p: Point2D[T]): Point2D[T] =
let
x = a.M11*p.x + a.M12*p.y + a.M13
y = a.M21*p.x + a.M22*p.y + a.M23
Point2D[T](x: x, y: y)
# making these so things like "line" that need a constructor don't stick out.
# 2x2 determinant: |a b|
# |c d| = ad - bc
# String rendering
#
template ff[S](x: S): string =
formatFloat(float(x), ffDefault, 0)
proc `$`*[S](p: Point2D[S]): string =
"P($1, $2)" % [ff(p.x), ff(p.y)]
proc `$`*[S](p: Vector2D[S]): string =
"V($1, $2)" % [ff(p.x), ff(p.y)]
proc `$`*[S](m: Matrix2x3[S]): string =
"M($1 $2 $3/$4 $5 $6)" % [ff(m.M11), ff(m.M12), ff(m.M13),
ff(m.M21), ff(m.M22), ff(m.M23)]
#
# Vector operators.
proc `-`*[S](a: Vector2D[S]): Vector2D[S] =
Vector2D[S](x: -a.x, y: -a.y)
proc `+`*[S](a, b: Vector2D[S]): Vector2D[S] =
Vector2D[S](x: a.x + b.x, y: a.y + b.y)
proc `-`*[S](a, b: Vector2D[S]): Vector2D[S] =
Vector2D[S](x: a.x - b.x, y: a.y - b.y)
proc `*`*[S](v: Vector2D[S], sc: S): Vector2D[S] =
Vector2D[S](x: v.x*sc, y: v.y*sc)
proc `*`*[S](sc: S, v: Vector2D[S]): Vector2D[S] =
Vector2D[S](x: v.x*sc, y: v.y*sc)
proc `/`*[S](v: Vector2D[S], sc: S): Vector2D[S] =
Vector2D[S](x: v.x/sc, y: v.y/sc)
proc `/`*[S](sc: S; v: Vector2D[S]): Vector2D[S] =
Vector2D[S](x: sc/v.x, y: sc/v.y)
proc `/`*[S](a, b: Vector2D[S]): Vector2D[S] =
Vector2D[S](x: a.x/b.x, y: a.y/b.y)
#proc vec[S](x, y: S): Vector2D[S]
proc vec[S](x, y: S): Vector2D[S] =
Vector2D[S](x: x, y: y)
if true:
# Comment out this let, and the program will fail to
# compile with a type mismatch, as expected.
let s3 = scale(vec(4.0, 4.0))
let barf = translation(Point2D[float32](x: 1, y: 1)) * rotation(float(0.7))
echo "Badness ", barf
|