I noticed that MJS.js defines var MJS_FLOAT_ARRAY_TYPE = Float64Array; while Vector2.js and Vector4.js use var MJS_FLOAT_ARRAY_TYPE = Float32Array;

I don't know if this was intentional or not, but I think this library should use the same type for all.

cc @felixLam

I imagine something similar to Matrix4.transform but for 2D rotation, scale and translation.

Hi there,

currrently there appears to be no function to create a Matrix4 from 16 fields. I currently need this in order to interact with the pixel matrix of a Mapbox GL js map. In an older version of this package the following was possible:

case matrixAsArray of
    [ m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44 ] ->
        mat4 m11 m12 m13 m14 m21 m22 m23 m24 m31 m32 m33 m34 m41 m42 m43 m44

    _ ->
        Matrix4.identity

Have a missed this function in the current release?

I would appreciate your feedback. I would imagine that it would work well to create a function with the following signature:

{-| Creates a Matrix4 from four Vec4
-}
makeFrom4Vec4 : Vec4 -> Vec4 -> Vec4 -> Vec4 -> Mat4
makeFrom4Vec4 = Native.MJS.m4x4makeBasis

or:

{-| Creates a Matrix4 from a list of elements. If the number of elements
is not exactly 16, this returns Nothing.
-}
makeFromList : List Float ->Maybe  Mat4
makeFromList list = 
    case list of
        [ m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44 ] ->
            Just M4x4.$ pixelMatrix

        _ ->
           Nothing

Perhaps these functions should be updated to return a Maybe Vec2 to avoid NaNs?

Vector2.direction caused a couple of bugs in my code which could have been prevented had it returned a Maybe instead.

> myVec4 = V4.vec4 1 2 3 4
{ 0 = 1, 1 = 2, 2 = 3, 3 = 4 } : Math.Vector4.Vec4
> V4.setX 7 myVec4
{ 0 = 0, 1 = 0, 2 = 0, 3 = 0, 4 = 0, 5 = 0, 6 = 0 } : Math.Vector4.Vec4
> V4.setY 7 myVec4
{ 0 = 0 } : Math.Vector4.Vec4
> V4.setZ 7 myVec4
{ 0 = 0 } : Math.Vector4.Vec4
> V4.setW 7 myVec4
{ 0 = 0 } : Math.Vector4.Vec4

Some background: Last week I have been working to get a ray casting example working for object picking purposes. I ran into an issue that two functions were missing:
Multiplying a Vec3 with a Float

multi : Vec3 -> Float -> Vec3
multi v1 f =
  vec3
    ((Vec3.getX v1) * f)
    ((Vec3.getY v1) * f)
    ((Vec3.getZ v1) * f)

Multiplying a Mat4x4 with a Vec4:

mulVector : Mat4 -> Vec4.Vec4 -> Vec4.Vec4
mulVector mat v =
    let
        rec =
            Mat4.toRecord mat

        r1 =
            Vec4.vec4 rec.m11 rec.m12 rec.m13 rec.m14

        r2 =
            Vec4.vec4 rec.m21 rec.m22 rec.m23 rec.m24

        r3 =
            Vec4.vec4 rec.m31 rec.m32 rec.m33 rec.m34

        r4 =
            Vec4.vec4 rec.m41 rec.m42 rec.m43 rec.m44
    in
        Vec4.vec4 (Vec4.dot r1 v) (Vec4.dot r2 v) (Vec4.dot r3 v) (Vec4.dot r4 v)

As you can see these are elm functions, the rest of the library is using native functions. Are you open to a PR for these? Or should they be converted to native js functions first?

This change 7c8d96a has broken my webgl game in Chrome 56.0.2924.87. Using linear-algebra 1.2.0 fixes the problem.

[2017-03-06: I copied this issue, created by @folkertdev, from https://github.com/elm-community/elm-linear-algebra/issues/18 per https://github.com//issues/7. -fredcy]

As it stands, the types in this library are somewhat tedious to work with. Especially when applying
the same operation to multiple components. @fredcy mentioned on slack that conversion to List/Array is planned, but this still requires two conversions (to and from List/Array).

suggestion

Implement a pointwise map and map2 which are equivalent (in the Vec2 case) to

map : (Float -> Float) -> Vec2 -> Vec2
map f = 
    fromTuple << (\(a, b) -> (f a, f b)) << toTuple

map2 : (Float -> Float -> Float) -> Vec2 -> Vec2 -> Vec2
map2 f a b = 
    let (left, right) = (toRecord a, toRecord b) 
    in 
	fromTuple ( f left.x right.x, f left.y right.y )

edit: implementing map3 in terms of map2 isn't very practical

concrete use case:

-- maximal and minimal components of two vectors 
boundingBox a b = (map2 min a b, map2 max a b) 

points of discussion

• A logical extension would be to also introduce mapX, mapY, map...
• pointwise is an alternative name to map2 that reads nicer (but is less consistent)
• map2 is restricted to functions of type Float -> Float -> Float, where Float -> Float -> a would be more useful. Rather than adding functionality to Vector, a Tuple.Extra package could implement the various mapping functions.

I just realised an issue I created was the same as one in the previously named elm-linear-algebra repo. Is it possible to migrate these issues as well as the code?

All types in linear algebra, except Mat4 may be constructed from floats and deconstructed back.

I need to get the raw data out of Mat4 for the CSS3D transforms in this example: https://github.com/w0rm/elm-webgl-playground/blob/master/CSS3d.elm