Merge pull request #312 from jonathan-s/moar-methods

Lots of methods for Math

src/js.rs

@@ -70,8 +70,8 @@ extern {
 extern {
     pub type Array;
 
-    /// The copyWithin() method shallow copies part of an array to another location in the same
+    /// The copyWithin() method shallow copies part of an array to another
-    /// array and returns it, without modifying its size.
+    /// location in the same array and returns it, without modifying its size.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin
     #[wasm_bindgen(method, js_name = copyWithin)]
@@ -84,29 +84,31 @@ extern {
     #[wasm_bindgen(method)]
     pub fn concat(this: &Array, array: &Array) -> Array;
 
-    /// The fill() method fills all the elements of an array from a start index to an
+    /// The fill() method fills all the elements of an array from a start index
-    /// end index with a static value. The end index is not included.
+    /// to an end index with a static value. The end index is not included.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill
     #[wasm_bindgen(method)]
     pub fn fill(this: &Array, value: JsValue, start: u32, end: u32) -> Array;
 
-    /// The length property of an object which is an instance of type Array sets or returns the number of elements in that array.
+    /// The length property of an object which is an instance of type Array
-    /// The value is an unsigned, 32-bit integer that is always numerically greater than the highest index in the array.
+    /// sets or returns the number of elements in that array. The value is an
+    /// unsigned, 32-bit integer that is always numerically greater than the
+    /// highest index in the array.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length
     #[wasm_bindgen(method, getter, structural)]
     pub fn length(this: &Array) -> u32;
 
-    /// The indexOf() method returns the first index at which a given element can be
+    /// The indexOf() method returns the first index at which a given element
-    /// found in the array, or -1 if it is not present.
+    /// can be found in the array, or -1 if it is not present.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
     #[wasm_bindgen(method, js_name = indexOf)]
     pub fn index_of(this: &Array, value: JsValue, from_index: i32) -> i32;
 
-    /// The includes() method determines whether an array includes a certain element,
+    /// The includes() method determines whether an array includes a certain
-    /// returning true or false as appropriate.
+    /// element, returning true or false as appropriate.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes
     #[wasm_bindgen(method)]
@@ -119,45 +121,45 @@ extern {
     #[wasm_bindgen(method)]
     pub fn join(this: &Array, delimiter: &str) -> JsString;
 
-    /// The lastIndexOf() method returns the last index at which a given element can
+    /// The lastIndexOf() method returns the last index at which a given element
-    /// be found in the array, or -1 if it is not present. The array is searched
+    /// can be found in the array, or -1 if it is not present. The array is
-    /// backwards, starting at fromIndex.
+    /// searched backwards, starting at fromIndex.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
     #[wasm_bindgen(method, js_name = lastIndexOf)]
     pub fn last_index_of(this: &Array, value: JsValue, from_index: i32) -> i32;
 
-    /// The pop() method removes the last element from an array and returns that element.
+    /// The pop() method removes the last element from an array and returns that
-    /// This method changes the length of the array.
+    /// element. This method changes the length of the array.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop
     #[wasm_bindgen(method)]
     pub fn pop(this: &Array) -> JsValue;
 
-    /// The push() method adds one or more elements to the end of an array and returns
+    /// The push() method adds one or more elements to the end of an array and
-    /// the new length of the array.
+    /// returns the new length of the array.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push
     #[wasm_bindgen(method)]
     pub fn push(this: &Array, value: JsValue) -> u32;
 
-    /// The reverse() method reverses an array in place.
+    /// The reverse() method reverses an array in place. The first array
-    /// The first array element becomes the last, and the last array element becomes the first.
+    /// element becomes the last, and the last array element becomes the first.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse
     #[wasm_bindgen(method)]
     pub fn reverse(this: &Array) -> Array;
 
-    /// The slice() method returns a shallow copy of a portion of an array into a new array
+    /// The slice() method returns a shallow copy of a portion of an array into
-    /// object selected from begin to end (end not included).
+    /// a new array object selected from begin to end (end not included).
     /// The original array will not be modified.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
     #[wasm_bindgen(method)]
     pub fn slice(this: &Array, start: u32, end: u32) -> Array;
 
-    /// The shift() method removes the first element from an array and returns that removed element.
+    /// The shift() method removes the first element from an array and returns
-    /// This method changes the length of the array.
+    /// that removed element. This method changes the length of the array.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift
     #[wasm_bindgen(method)]
@@ -174,14 +176,15 @@ extern {
     #[wasm_bindgen(method)]
     pub fn sort(this: &Array) -> Array;
 
-    /// The toString() method returns a string representing the specified array and its elements.
+    /// The toString() method returns a string representing the specified array
+    /// and its elements.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString
     #[wasm_bindgen(method, js_name = toString)]
     pub fn to_string(this: &Array) -> JsString;
 
-    /// The unshift() method adds one or more elements to the beginning of an array
+    /// The unshift() method adds one or more elements to the beginning of an
-    /// and returns the new length of the array.
+    /// array and returns the new length of the array.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift
     #[wasm_bindgen(method)]
@@ -193,13 +196,15 @@ extern {
 extern {
     pub type ArrayIterator;
 
-    /// The keys() method returns a new Array Iterator object that contains the keys for each index in the array.
+    /// The keys() method returns a new Array Iterator object that contains the
+    /// keys for each index in the array.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/keys
     #[wasm_bindgen(method)]
     pub fn keys(this: &Array) -> ArrayIterator;
 
-    /// The entries() method returns a new Array Iterator object that contains the key/value pairs for each index in the array.
+    /// The entries() method returns a new Array Iterator object that contains
+    /// the key/value pairs for each index in the array.
     ///
     /// http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries
     #[wasm_bindgen(method)]
@@ -217,14 +222,101 @@ extern {
     #[wasm_bindgen(method, getter, structural)]
     pub fn length(this: &JsFunction) -> u32;
 
-    /// A Function object's read-only name property indicates the function's name as specified when it was created
+    /// A Function object's read-only name property indicates the function's
-    /// or "anonymous" for functions created anonymously.
+    /// name as specified when it was created or "anonymous" for functions
+    /// created anonymously.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
     #[wasm_bindgen(method, getter, structural)]
     pub fn name(this: &JsFunction) -> JsString;
 }
 
+// Math
+#[wasm_bindgen]
+extern {
+    pub type Math;
+    /// The Math.abs() function returns the absolute value of a number, that is
+    /// Math.abs(x) = |x|
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn abs(number: i32) -> Number;
+
+    /// The Math.acos() function returns the arccosine (in radians) of a
+    /// number, that is ∀x∊[-1;1]
+    /// Math.acos(x) = arccos(x) = the unique y∊[0;π] such that cos(y)=x
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn acos(adjacent: i32, hypotenuse: i32) -> Number;
+
+    /// The Math.acosh() function returns the hyperbolic arc-cosine of a
+    /// number, that is ∀x ≥ 1
+    /// Math.acosh(x) = arcosh(x) = the unique y ≥ 0 such that cosh(y) = x
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn acosh(number: i32) -> Number;
+
+    /// The Math.asin() function returns the arcsine (in radians) of a
+    /// number, that is ∀x ∊ [-1;1]
+    /// Math.asin(x) = arcsin(x) = the unique y∊[-π2;π2] such that sin(y) = x
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn asin(number: i32) -> Number;
+
+    /// The Math.asinh() function returns the hyperbolic arcsine of a
+    /// number, that is Math.asinh(x) = arsinh(x) = the unique y such that sinh(y) = x
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn asinh(number: i32) -> Number;
+
+    /// The Math.atan() function returns the arctangent (in radians) of a
+    /// number, that is Math.atan(x) = arctan(x) = the unique y ∊ [-π2;π2]such that
+    /// tan(y) = x
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn atan(number: i32) -> Number;
+
+    /// The Math.atan2() function returns the arctangent of the quotient of
+    /// its arguments.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn atan2(y: i32, x: i32) -> Number;
+
+    /// The Math.atanh() function returns the hyperbolic arctangent of a number,
+    /// that is ∀x ∊ (-1,1), Math.atanh(x) = arctanh(x) = the unique y such that
+    /// tanh(y) = x
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn atanh(x: i32) -> Number;
+
+
+    /// The Math.cbrt() function returns the cube root of a number, that is
+    /// Math.cbrt(x) = x^3 = the unique y such that y^3 = x
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn cbrt(x: i32) -> Number;
+
+    /// The Math.ceil() function returns the smallest integer greater than
+    /// or equal to a given number.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn ceil(x: f32) -> Number;
+
+    /// The Math.clz32() function returns the number of leading zero bits in
+    /// the 32-bit binary representation of a number.
+    ///
+    /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
+    #[wasm_bindgen(static_method_of = Math)]
+    pub fn clz32(x: i32) -> Number;
+}
+
 // Number.
 #[wasm_bindgen]
 extern {
@@ -314,8 +406,8 @@ extern {
     pub fn property_is_enumerable(this: &Object, property: &JsValue) -> bool;
 
     /// The toLocaleString() method returns a string representing the object.
-    /// This method is meant to be overridden by derived objects for locale-specific
+    /// This method is meant to be overridden by derived objects for
-    /// purposes.
+    /// locale-specific purposes.
     ///
     /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
     #[wasm_bindgen(method, js_name = toLocaleString)]

tests/all/js_globals/Math.rs

@@ -0,0 +1,294 @@
+#![allow(non_snake_case)]
+
+use super::project;
+
+
+#[test]
+fn abs() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn abs(number: i32) -> js::Number {
+                js::Math::abs(number)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.abs(-32), Math.abs(-32));
+                assert.equal(wasm.abs(32), 32);
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn acos() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn acos(adjacent: i32, hypotenuse: i32) -> js::Number {
+                js::Math::acos(adjacent, hypotenuse)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.acos(-1, 1), Math.PI);
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn acosh() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn acosh(number: i32) -> js::Number {
+                js::Math::acosh(number)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.acosh(1), 0);
+                assert.equal(wasm.acosh(2), Math.acosh(2));
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn asin() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn asin(opposite: i32, hypotenuse: i32) -> js::Number {
+                js::Math::asin(opposite / hypotenuse)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.asin(1, 1), Math.asin(1));
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn asinh() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn asinh(number: i32) -> js::Number {
+                js::Math::asinh(number)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.asinh(1), Math.asinh(1));
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn atan() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn atan(number: i32) -> js::Number {
+                js::Math::atan(number)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.atan(1), Math.atan(1));
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn atan2() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn atan2(x: i32, y: i32) -> js::Number {
+                js::Math::atan2(x, y)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.atan2(1, 2), Math.atan2(1, 2));
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn atanh() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn atanh(x: i32) -> js::Number {
+                js::Math::atanh(x)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.atanh(1), Math.atanh(1));
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn cbrt() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn cbrt(x: i32) -> js::Number {
+                js::Math::cbrt(x)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.cbrt(27), 3);
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn ceil() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn ceil(x: f32) -> js::Number {
+                js::Math::ceil(x)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.ceil(1.1), 2);
+                assert.equal(wasm.ceil(-1.1), -1);
+            }
+        "#)
+        .test()
+}
+
+#[test]
+fn clz32() {
+    project()
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section)]
+
+            extern crate wasm_bindgen;
+            use wasm_bindgen::prelude::*;
+            use wasm_bindgen::js;
+
+            #[wasm_bindgen]
+            pub fn clz32(x: i32) -> js::Number {
+                js::Math::clz32(x)
+            }
+        "#)
+        .file("test.ts", r#"
+            import * as assert from "assert";
+            import * as wasm from "./out";
+
+            export function test() {
+                assert.equal(wasm.clz32(1), 31);
+                assert.equal(wasm.clz32(1000), 22);
+            }
+        "#)
+        .test()
+}

tests/all/js_globals/mod.rs

@@ -8,6 +8,7 @@ mod ArrayIterator;
 mod JsFunction;
 mod JsString;
 mod Number;
+mod Math;
 
 #[test]
 #[cfg(feature = "std")]