vec

4.0.0
4.1.0 4.0.0 3.5.1 3.5.0 3.4.1 3.4.0 3.3.0 3.2.1 3.2.0 3.1.0 3.0.3 3.0.2 3.0.1 3.0.0 2.0.0 1.4.0 1.3.5 1.3.4 1.3.3 1.3.2 1.3.1 1.3.0 1.2.0 1.1.0 1.0.0
A vectors library for the Gleam programming language
HexDocs
Current section
Files
Jump to
Readme 25 Versions 2 Dependencies Dependants Files Activity
vec src vec@vec4.erl
Raw
src/vec@vec4.erl

-module(vec@vec4).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/vec/vec4.gleam").
-export([splat/1, from_tuple/1, to_tuple/1, to_list/1, x/1, y/1, z/1, w/1, map_x/2, map_y/2, map_z/2, map_w/2, swap_xy/1, swap_xz/1, swap_xw/1, swap_yz/1, swap_yw/1, swap_zw/1, map/2, map2/3, map3/4, result/1]).
-export_type([vec4/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type vec4(HRT) :: {vec4, HRT, HRT, HRT, HRT}.

-file("src/vec/vec4.gleam", 16).
?DOC(
    " Creates a vector with all elements set to a value.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert splat(12) == Vec4(12, 12, 12, 12)\n"
    " ```\n"
).
-spec splat(HRV) -> vec4(HRV).
splat(Value) ->
    {vec4, Value, Value, Value, Value}.

-file("src/vec/vec4.gleam", 28).
?DOC(
    " Converts a tuple of the contained elements into a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert #(12, -34, 420, 69) |> from_tuple == Vec4(12, -34, 420, 69)\n"
    " ```\n"
).
-spec from_tuple({HRX, HRX, HRX, HRX}) -> vec4(HRX).
from_tuple(Tuple) ->
    {vec4,
        erlang:element(1, Tuple),
        erlang:element(2, Tuple),
        erlang:element(3, Tuple),
        erlang:element(4, Tuple)}.

-file("src/vec/vec4.gleam", 40).
?DOC(
    " Converts the vector into a tuple of the contained elements.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> to_tuple == #(12, -34, 420, 69)\n"
    " ```\n"
).
-spec to_tuple(vec4(HRZ)) -> {HRZ, HRZ, HRZ, HRZ}.
to_tuple(Vector) ->
    {erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 52).
?DOC(
    " Converts the vector into a list of the contained elements.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> to_list == [12, -34, 420, 69]\n"
    " ```\n"
).
-spec to_list(vec4(HSB)) -> list(HSB).
to_list(Vector) ->
    [erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector),
        erlang:element(5, Vector)].

-file("src/vec/vec4.gleam", 64).
?DOC(
    " Returns the x element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> x == 12\n"
    " ```\n"
).
-spec x(vec4(HSE)) -> HSE.
x(Vector) ->
    erlang:element(2, Vector).

-file("src/vec/vec4.gleam", 76).
?DOC(
    " Returns the y element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> y == -34\n"
    " ```\n"
).
-spec y(vec4(HSG)) -> HSG.
y(Vector) ->
    erlang:element(3, Vector).

-file("src/vec/vec4.gleam", 88).
?DOC(
    " Returns the z element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> z == 420\n"
    " ```\n"
).
-spec z(vec4(HSI)) -> HSI.
z(Vector) ->
    erlang:element(4, Vector).

-file("src/vec/vec4.gleam", 100).
?DOC(
    " Returns the w element in a vector.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> w == 69\n"
    " ```\n"
).
-spec w(vec4(HSK)) -> HSK.
w(Vector) ->
    erlang:element(5, Vector).

-file("src/vec/vec4.gleam", 115).
?DOC(
    " Returns a new vector with the x element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(12, -34, 420, 69)\n"
    "   |> map_x(fn(n) { n * 2 })\n"
    "   == Vec4(24, -34, 420, 69)\n"
    " ```\n"
).
-spec map_x(vec4(HSM), fun((HSM) -> HSM)) -> vec4(HSM).
map_x(Vector, Fun) ->
    {vec4,
        Fun(erlang:element(2, Vector)),
        erlang:element(3, Vector),
        erlang:element(4, Vector),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 130).
?DOC(
    " Returns a new vector with the y element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(12, -34, 420, 69)\n"
    "   |> map_y(fn(n) { n * 2 })\n"
    "   == Vec4(12, -68, 420, 69)\n"
    " ```\n"
).
-spec map_y(vec4(HSP), fun((HSP) -> HSP)) -> vec4(HSP).
map_y(Vector, Fun) ->
    {vec4,
        erlang:element(2, Vector),
        Fun(erlang:element(3, Vector)),
        erlang:element(4, Vector),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 145).
?DOC(
    " Returns a new vector with the z element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(12, -34, 420, 69)\n"
    "   |> map_z(fn(n) { n * 2 })\n"
    "   == Vec4(12, -34, 840, 69)\n"
    " ```\n"
).
-spec map_z(vec4(HSS), fun((HSS) -> HSS)) -> vec4(HSS).
map_z(Vector, Fun) ->
    {vec4,
        erlang:element(2, Vector),
        erlang:element(3, Vector),
        Fun(erlang:element(4, Vector)),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 160).
?DOC(
    " Returns a new vector with the w element having had `with` applied to it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(12, -34, 420, 69)\n"
    "   |> map_w(fn(n) { n * 2 })\n"
    "   == Vec4(12, -34, 420, 138)\n"
    " ```\n"
).
-spec map_w(vec4(HSV), fun((HSV) -> HSV)) -> vec4(HSV).
map_w(Vector, Fun) ->
    {vec4,
        erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector),
        Fun(erlang:element(5, Vector))}.

-file("src/vec/vec4.gleam", 172).
?DOC(
    " Returns a new vector with the x and y elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> swap_xy == Vec4(-34, 12, 420, 69)\n"
    " ```\n"
).
-spec swap_xy(vec4(HSY)) -> vec4(HSY).
swap_xy(Vector) ->
    {vec4,
        erlang:element(3, Vector),
        erlang:element(2, Vector),
        erlang:element(4, Vector),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 184).
?DOC(
    " Returns a new vector with the x and z elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> swap_xz == Vec4(420, -34, 12, 69)\n"
    " ```\n"
).
-spec swap_xz(vec4(HTB)) -> vec4(HTB).
swap_xz(Vector) ->
    {vec4,
        erlang:element(4, Vector),
        erlang:element(3, Vector),
        erlang:element(2, Vector),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 196).
?DOC(
    " Returns a new vector with the x and w elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> swap_xw == Vec4(69, -34, 420, 12)\n"
    " ```\n"
).
-spec swap_xw(vec4(HTE)) -> vec4(HTE).
swap_xw(Vector) ->
    {vec4,
        erlang:element(5, Vector),
        erlang:element(3, Vector),
        erlang:element(4, Vector),
        erlang:element(2, Vector)}.

-file("src/vec/vec4.gleam", 208).
?DOC(
    " Returns a new vector with the y and z elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> swap_yz == Vec4(12, 420, -34, 69)\n"
    " ```\n"
).
-spec swap_yz(vec4(HTH)) -> vec4(HTH).
swap_yz(Vector) ->
    {vec4,
        erlang:element(2, Vector),
        erlang:element(4, Vector),
        erlang:element(3, Vector),
        erlang:element(5, Vector)}.

-file("src/vec/vec4.gleam", 220).
?DOC(
    " Returns a new vector with the y and w elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> swap_yw == Vec4(12, 69, 420, -34)\n"
    " ```\n"
).
-spec swap_yw(vec4(HTK)) -> vec4(HTK).
swap_yw(Vector) ->
    {vec4,
        erlang:element(2, Vector),
        erlang:element(5, Vector),
        erlang:element(4, Vector),
        erlang:element(3, Vector)}.

-file("src/vec/vec4.gleam", 232).
?DOC(
    " Returns a new vector with the z and w elements swaped.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert Vec4(12, -34, 420, 69) |> swap_zw == Vec4(12, -34, 69, 420)\n"
    " ```\n"
).
-spec swap_zw(vec4(HTN)) -> vec4(HTN).
swap_zw(Vector) ->
    {vec4,
        erlang:element(2, Vector),
        erlang:element(3, Vector),
        erlang:element(5, Vector),
        erlang:element(4, Vector)}.

-file("src/vec/vec4.gleam", 248).
?DOC(
    " Returns a new vector containing only the elements of the first vector after\n"
    " the function has been applied to each one.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(12, -34, 420, 69)\n"
    "   |> map(fn(x) { x * 2 })\n"
    "   == Vec4(24, -68, 840, 138)\n"
    " ```\n"
).
-spec map(vec4(HTQ), fun((HTQ) -> HTS)) -> vec4(HTS).
map(Vector, Fun) ->
    {vec4,
        Fun(erlang:element(2, Vector)),
        Fun(erlang:element(3, Vector)),
        Fun(erlang:element(4, Vector)),
        Fun(erlang:element(5, Vector))}.

-file("src/vec/vec4.gleam", 262).
?DOC(
    " Combines two vectors into a single vector using the given function.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   map2(Vec4(12, -34, 420, 69), Vec4(1, 2, 3, 4), fn(x, y) { x * y })\n"
    "   == Vec4(12, -68, 1260, 276)\n"
    " ```\n"
).
-spec map2(vec4(HTU), vec4(HTW), fun((HTU, HTW) -> HTY)) -> vec4(HTY).
map2(A, B, Fun) ->
    {vec4,
        Fun(erlang:element(2, A), erlang:element(2, B)),
        Fun(erlang:element(3, A), erlang:element(3, B)),
        Fun(erlang:element(4, A), erlang:element(4, B)),
        Fun(erlang:element(5, A), erlang:element(5, B))}.

-file("src/vec/vec4.gleam", 285).
?DOC(
    " Combines three vectors into a single vector using the given function.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " fn linear_interpolation(weight: Float, a: Float, b: Float) -> Float {\n"
    "   a +. { b -. a } *. weight\n"
    " }\n"
    "\n"
    " assert\n"
    "   splat(0.6)\n"
    "   |> map3(\n"
    "     Vec4(1.2, -3.4, 42.0, 0.69),\n"
    "     Vec4(1.0, 2.1, -5.4, 7.5),\n"
    "     linear_interpolation,\n"
    "   )\n"
    "   == Vec4(1.08, -0.1, 13.56, 4.78)\n"
    " ```\n"
).
-spec map3(vec4(HUA), vec4(HUC), vec4(HUE), fun((HUA, HUC, HUE) -> HUE)) -> vec4(HUE).
map3(A, B, C, Fun) ->
    {vec4,
        Fun(erlang:element(2, A), erlang:element(2, B), erlang:element(2, C)),
        Fun(erlang:element(3, A), erlang:element(3, B), erlang:element(3, C)),
        Fun(erlang:element(4, A), erlang:element(4, B), erlang:element(4, C)),
        Fun(erlang:element(5, A), erlang:element(5, B), erlang:element(5, C))}.

-file("src/vec/vec4.gleam", 319).
?DOC(
    " Combines a vector of results into a single result. If all elements in the\n"
    " vector are `Ok` then returns an `Ok` holding the vector of values. If any\n"
    " element is `Error` then returns the first error.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(Ok(12), Ok(-34), Ok(420), Ok(69))\n"
    "   |> result\n"
    "   == Ok(Vec4(12, -34, 420, 69))\n"
    " ```\n"
    "\n"
    " ```gleam\n"
    " assert\n"
    "   Vec4(Ok(12), Error(\"foo\"), Ok(420), Error(\"bar\"))\n"
    "   |> result\n"
    "   == Error(\"foo\")\n"
    " ```\n"
).
-spec result(vec4({ok, HUH} | {error, HUI})) -> {ok, vec4(HUH)} | {error, HUI}.
result(Vector) ->
    case Vector of
        {vec4, {ok, X}, {ok, Y}, {ok, Z}, {ok, W}} ->
            {ok, {vec4, X, Y, Z, W}};

        {vec4, {error, Error}, _, _, _} ->
            {error, Error};

        {vec4, _, {error, Error@1}, _, _} ->
            {error, Error@1};

        {vec4, _, _, {error, Error@2}, _} ->
            {error, Error@2};

        {vec4, _, _, _, {error, Error@3}} ->
            {error, Error@3}
    end.
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT