I've put together a branch that introduces three new functions for the `Real`

module:

```
protocol Real {
...
+ static func cos(piTimes x: Self) -> Self
+ static func sin(piTimes x: Self) -> Self
+ static func tan(piTimes x: Self) -> Self
}
```

These functions compute, respectively, *cos(πx)*, *sin(πx)*, and *tan(πx)* in a manner that is much more accurate than is possible with the "obvious" expressions like `.cos(.pi * x)`

, because π cannot be exactly represented as a FloatingPoint type, so `.pi * x`

always introduces a small relative error, which can become a large relative error in the face of further operations. This makes getting many common cases exactly right significantly easier. E.g.:

```
[ 1> import Real
[ 2> var a = Double.tan(.pi * 1.5)
a: Double = 5443746451065123 // huh?
[ 3> var b = Double.tan(piTimes: 1.5)
b: Double = -Inf // yay!
[ 4> var c = Float.sin(.pi * 1000000)
c: Float = -0.152986646 // what the ...
[ 5> var d = Float.sin(piTimes: 1000000)
d: Float = 0 // yay!
```

I have some more to do, and need to commit the tests, but they're basically working and you can play with them now if you grab the branch.

The *functionality* provided by these operations is something that I'm quite set on adding, but I am less committed to this particular spelling, and am interested in alternatives. Some possibilities:

```
let a = Double.cospi(x) // C-family style
let b = cos(πx: y) -> Self // too-clever by half
... your suggestion here!
```

Especially worth keeping in mind is a pattern that provides names for *inverse* trig-pi functions, which have an implicit scale of π on their *result* rather than their argument.