https://github.com/Jam3/math-as-code

Skip to content
 
Sign up

  * Why GitHub?
    Features -
      + Mobile -
      + Actions -
      + Codespaces -
      + Packages -
      + Security -
      + Code review -
      + Issues -
      + Integrations -
      + GitHub Sponsors -
      + Customer stories-
  * Team
  * Enterprise
  * Explore
      + Explore GitHub -

    Learn and contribute

      + Topics -
      + Collections -
      + Trending -
      + Learning Lab -
      + Open source guides -

    Connect with others

      + The ReadME Project -
      + Events -
      + Community forum -
      + GitHub Education -
      + GitHub Stars program -
  * Marketplace
  * Pricing
    Plans -
      + Compare plans -
      + Contact Sales -
      + Education -

[                    ] 

  *  
    #
    In this repository All GitHub |
    Jump to |

  * No suggested jump to results

  *  
    #
    In this repository All GitHub |
    Jump to |
  *  
    #
    In this organization All GitHub |
    Jump to |
  *  
    #
    In this repository All GitHub |
    Jump to |

Sign in
Sign up
{{ message }}

Jam3 / math-as-code Public

  * Notifications
  * Star 12.2k
  * Fork 913

a cheat-sheet for mathematical notation in code form

MIT License
12.2k stars 913 forks
Star
Notifications

  * Code
  * Issues 27
  * Pull requests 5
  * Actions
  * Projects 0
  * Wiki
  * Security
  * Insights

More

  * Code
  * Issues
  * Pull requests
  * Actions
  * Projects
  * Wiki
  * Security
  * Insights

master
Switch branches/tags
[                    ]
Branches Tags
Could not load branches
Nothing to show
{{ refName }} default View all branches
Could not load tags
Nothing to show
{{ refName }} default
View all tags
5 branches 0 tags
Code

  *  
    Clone
    HTTPS GitHub CLI
    [https://github.com/J]

    Use Git or checkout with SVN using the web URL.

    [gh repo clone Jam3/m]

    Work fast with our official CLI. Learn more.

  * Open with GitHub Desktop
  * Download ZIP

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Go back

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Go back

Launching Xcode

If nothing happens, download Xcode and try again.

Go back

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

@mattdesl
mattdesl Merge pull request #41 from chocolateboy/
fix-complex-number-typo
...
1d5c84c Jun 26, 2019
Merge pull request #41 from chocolateboy/fix-complex-number-typo

fix complex-number typo

1d5c84c

Git stats

  * 135 commits

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
.gitignore
gitignore test
Jun 30, 2015
.npmignore
bam!
Jun 29, 2015
CONTRIBUTING.md
contributing info
Jul 1, 2015
LICENSE.md
bam!
Jun 29, 2015
PYTHON-README.md
Update PYTHON-README.md
May 30, 2019
README-zh.md
Merge pull request #62 from nshen/master
Sep 19, 2018
README.md
Merge pull request #41 from chocolateboy/fix-complex-number-typo
Jun 26, 2019
package.json
sets functions and arrow updates
Jul 2, 2015
View code
[                    ]
math-as-code foreword contents variable name conventions equals
symbols square root and complex numbers dot & cross scalar
multiplication vector multiplication dot product cross product sigma
capital Pi pipes absolute value Euclidean norm determinant hat
element common number sets R real numbers Q rational numbers Z
integers N natural numbers C complex numbers function piecewise
function common functions function notation prime floor & ceiling
arrows material implication equality conjunction & disjunction
logical negation intervals more... Contributing License

README.md

 math-as-code

    Chinese translation (Zhong Wen Ban )
    Python version (English)

This is a reference to ease developers into mathematical notation by
showing comparisons with JavaScript code.

Motivation: Academic papers can be intimidating for self-taught game
and graphics programmers. :)

This guide is not yet finished. If you see errors or want to
contribute, please open a ticket or send a PR.

    Note: For brevity, some code examples make use of npm packages.
    You can refer to their GitHub repos for implementation details.

 foreword

Mathematical symbols can mean different things depending on the
author, context and the field of study (linear algebra, set theory,
etc). This guide may not cover all uses of a symbol. In some cases,
real-world references (blog posts, publications, etc) will be cited
to demonstrate how a symbol might appear in the wild.

For a more complete list, refer to Wikipedia - List of Mathematical
Symbols.

For simplicity, many of the code examples here operate on floating
point values and are not numerically robust. For more details on why
this may be a problem, see Robust Arithmetic Notes by Mikola Lysenko.

 contents

  * variable name conventions
  * equals = [?] [?] :=
  * square root and complex numbers [?] i
  * dot & cross * x [?]
      + scalar multiplication
      + vector multiplication
      + dot product
      + cross product
  * sigma S - summation
  * capital Pi P - products of sequences
  * pipes ||
      + absolute value
      + Euclidean norm
      + determinant
  * hat a - unit vector
  * "element of" [?] [?]
  * common number sets R Z Q N
  * function f
      + piecewise function
      + common functions
      + function notation - -
  * prime '
  * floor & ceiling [?] [?]
  * arrows
      + material implication = -
      + equality < >= [?]
      + conjunction & disjunction [?] [?]
  * logical negation ! ~ !
  * intervals
  * more...

 variable name conventions

There are a variety of naming conventions depending on the context
and field of study, and they are not always consistent. However, in
some of the literature you may find variable names to follow a
pattern like so:

  * s - italic lowercase letters for scalars (e.g. a number)
  * x - bold lowercase letters for vectors (e.g. a 2D point)
  * A - bold uppercase letters for matrices (e.g. a 3D
    transformation)
  * th - italic lowercase Greek letters for constants and special
    variables (e.g. polar angle th, theta)

This will also be the format of this guide.

 equals symbols

There are a number of symbols resembling the equals sign =. Here are
a few common examples:

  * = is for equality (values are the same)
  * [?] is for inequality (value are not the same)
  * [?] is for approximately equal to (p [?] 3.14159)
  * := is for definition (A is defined as B)

In JavaScript:

// equality
2 === 3

// inequality
2 !== 3

// approximately equal
almostEqual(Math.PI, 3.14159, 1e-5)

function almostEqual(a, b, epsilon) {
  return Math.abs(a - b) <= epsilon
}

You might see the :=, =: and = symbols being used for definition.^1

For example, the following defines x to be another name for 2kj.

equals1

In JavaScript, we might use var to define our variables and provide
aliases:

var x = 2 * k * j

However, this is mutable, and only takes a snapshot of the values at
that time. Some languages have pre-processor #define statements,
which are closer to a mathematical define.

A more accurate define in JavaScript (ES6) might look a bit like
this:

const f = (k, j) => 2 * k * j

The following, on the other hand, represents equality:

equals2

The above equation might be interpreted in code as an assertion:

console.assert(x === (2 * k * j))

 square root and complex numbers

A square root operation is of the form:

squareroot

In programming we use a sqrt function, like so:

var x = 9;
console.log(Math.sqrt(x));
//=> 3

Complex numbers are expressions of the form complex, where a is the
real part and b is the imaginary part. The imaginary number i is
defined as:

imaginary.

In JavaScript, there is no built-in functionality for complex
numbers, but there are some libraries that support complex number
arithmetic. For example, using mathjs:

var math = require('mathjs')

var a = math.complex(3, -1)
//=> { re: 3, im: -1 }

var b = math.sqrt(-1)
//=> { re: 0, im: 1 }

console.log(math.multiply(a, b).toString())
//=> '1 + 3i'

The library also supports evaluating a string expression, so the
above could be re-written as:

console.log(math.eval('(3 - i) * i').toString())
//=> '1 + 3i'

Other implementations:

  * immutable-complex
  * complex-js
  * Numeric-js

 dot & cross

The dot * and cross x symbols have different uses depending on
context.

They might seem obvious, but it's important to understand the subtle
differences before we continue into other sections.

 scalar multiplication

Both symbols can represent simple multiplication of scalars. The
following are equivalent:

dotcross1

In programming languages we tend to use asterisk for multiplication:

var result = 5 * 4

Often, the multiplication sign is only used to avoid ambiguity (e.g.
between two numbers). Here, we can omit it entirely:

dotcross2

If these variables represent scalars, the code would be:

var result = 3 * k * j

 vector multiplication

To denote multiplication of one vector with a scalar, or element-wise
multiplication of a vector with another vector, we typically do not
use the dot * or cross x symbols. These have different meanings in
linear algebra, discussed shortly.

Let's take our earlier example but apply it to vectors. For
element-wise vector multiplication, you might see an open dot [?] to
represent the Hadamard product.^2

dotcross3

In other instances, the author might explicitly define a different
notation, such as a circled dot [?] or a filled circle *.^3

Here is how it would look in code, using arrays [x, y] to represent
the 2D vectors.

var s = 3
var k = [ 1, 2 ]
var j = [ 2, 3 ]

var tmp = multiply(k, j)
var result = multiplyScalar(tmp, s)
//=> [ 6, 18 ]

Our multiply and multiplyScalar functions look like this:

function multiply(a, b) {
  return [ a[0] * b[0], a[1] * b[1] ]
}

function multiplyScalar(a, scalar) {
  return [ a[0] * scalar, a[1] * scalar ]
}

Similarly, matrix multiplication typically does not use the dot * or
cross symbol x. Matrix multiplication will be covered in a later
section.

 dot product

The dot symbol * can be used to denote the dot product of two
vectors. Sometimes this is called the scalar product since it
evaluates to a scalar.

dotcross4

It is a very common feature of linear algebra, and with a 3D vector
it might look like this:

var k = [ 0, 1, 0 ]
var j = [ 1, 0, 0 ]

var d = dot(k, j)
//=> 0

The result 0 tells us our vectors are perpendicular. Here is a dot
function for 3-component vectors:

function dot(a, b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}

 cross product

The cross symbol x can be used to denote the cross product of two
vectors.

dotcross5

In code, it would look like this:

var k = [ 0, 1, 0 ]
var j = [ 1, 0, 0 ]

var result = cross(k, j)
//=> [ 0, 0, -1 ]

Here, we get [ 0, 0, -1 ], which is perpendicular to both k and j.

Our cross function:

function cross(a, b) {
  var ax = a[0], ay = a[1], az = a[2],
    bx = b[0], by = b[1], bz = b[2]

  var rx = ay * bz - az * by
  var ry = az * bx - ax * bz
  var rz = ax * by - ay * bx
  return [ rx, ry, rz ]
}

For other implementations of vector multiplication, cross product,
and dot product:

  * gl-vec3
  * gl-vec2
  * vectors - includes n-dimensional

 sigma

The big Greek S (Sigma) is for Summation. In other words: summing up
some numbers.

sigma

Here, i=1 says to start at 1 and end at the number above the Sigma,
100. These are the lower and upper bounds, respectively. The i to the
right of the "E" tells us what we are summing. In code:

var sum = 0
for (var i = 1; i <= 100; i++) {
  sum += i
}

The result of sum is 5050.

Tip: With whole numbers, this particular pattern can be optimized to
the following:

var n = 100 // upper bound
var sum = (n * (n + 1)) / 2

Here is another example where the i, or the "what to sum," is
different:

sum2

In code:

var sum = 0
for (var i = 1; i <= 100; i++) {
  sum += (2 * i + 1)
}

The result of sum is 10200.

The notation can be nested, which is much like nesting a for loop.
You should evaluate the right-most sigma first, unless the author has
enclosed them in parentheses to alter the order. However, in the
following case, since we are dealing with finite sums, the order does
not matter.

sigma3

In code:

var sum = 0
for (var i = 1; i <= 2; i++) {
  for (var j = 4; j <= 6; j++) {
    sum += (3 * i * j)
  }
}

Here, sum will be 135.

 capital Pi

The capital Pi or "Big Pi" is very similar to Sigma, except we are
using multiplication to find the product of a sequence of values.

Take the following:

capitalPi

In code, it might look like this:

var value = 1
for (var i = 1; i <= 6; i++) {
  value *= i
}

Where value will evaluate to 720.

 pipes

Pipe symbols, known as bars, can mean different things depending on
the context. Below are three common uses: absolute value, Euclidean
norm, and determinant.

These three features all describe the length of an object.

 absolute value

pipes1

For a number x, |x| means the absolute value of x. In code:

var x = -5
var result = Math.abs(x)
// => 5

 Euclidean norm

pipes4

For a vector v, ||v|| is the Euclidean norm of v. It is also referred
to as the "magnitude" or "length" of a vector.

Often this is represented by double-bars to avoid ambiguity with the
absolute value notation, but sometimes you may see it with single
bars:

pipes2

Here is an example using an array [x, y, z] to represent a 3D vector.

var v = [ 0, 4, -3 ]
length(v)
//=> 5

The length function:

function length (vec) {
  var x = vec[0]
  var y = vec[1]
  var z = vec[2]
  return Math.sqrt(x * x + y * y + z * z)
}

Other implementations:

  * magnitude - n-dimensional
  * gl-vec2/length - 2D vector
  * gl-vec3/length - 3D vector

 determinant

pipes3

For a matrix A, |A| means the determinant of matrix A.

Here is an example computing the determinant of a 2x2 matrix,
represented by a flat array in column-major format.

var determinant = require('gl-mat2/determinant')

var matrix = [ 1, 0, 0, 1 ]
var det = determinant(matrix)
//=> 1

Implementations:

  * gl-mat4/determinant - also see gl-mat3 and gl-mat2
  * ndarray-determinant
  * glsl-determinant
  * robust-determinant
  * robust-determinant-2 and robust-determinant-3, specifically for
    2x2 and 3x3 matrices, respectively

 hat

In geometry, the "hat" symbol above a character is used to represent
a unit vector. For example, here is the unit vector of a:

hat

In Cartesian space, a unit vector is typically length 1. That means
each part of the vector will be in the range of -1.0 to 1.0. Here we
normalize a 3D vector into a unit vector:

var a = [ 0, 4, -3 ]
normalize(a)
//=> [ 0, 0.8, -0.6 ]

Here is the normalize function, operating on 3D vectors:

function normalize(vec) {
  var x = vec[0]
  var y = vec[1]
  var z = vec[2]
  var squaredLength = x * x + y * y + z * z

  if (squaredLength > 0) {
    var length = Math.sqrt(squaredLength)
    vec[0] = x / length
    vec[1] = y / length
    vec[2] = z / length
  }
  return vec
}

Other implementations:

  * gl-vec3/normalize and gl-vec2/normalize
  * vectors/normalize-nd (n-dimensional)

 element

In set theory, the "element of" symbol [?] and [?] can be used to
describe whether something is an element of a set. For example:

element1

Here we have a set of numbers A { 3, 9, 14 } and we are saying 3 is
an "element of" that set.

A simple implementation in ES5 might look like this:

var A = [ 3, 9, 14 ]

A.indexOf(3) >= 0
//=> true

However, it would be more accurate to use a Set which only holds
unique values. This is a feature of ES6.

var A = new Set([ 3, 9, 14 ])

A.has(3)
//=> true

The backwards [?] is the same, but the order changes:

element2

You can also use the "not an element of" symbols [?] and [?] like so:

element3

 common number sets

You may see some some large Blackboard letters among equations.
Often, these are used to describe sets.

For example, we might describe k to be an element of the set R.

real

Listed below are a few common sets and their symbols.

 R real numbers

The large R describes the set of real numbers. These include
integers, as well as rational and irrational numbers.

JavaScript treats floats and integers as the same type, so the
following would be a simple test of our k [?] R example:

function isReal (k) {
  return typeof k === 'number' && isFinite(k);
}

Note: Real numbers are also finite, as in, not infinite.

 Q rational numbers

Rational numbers are real numbers that can be expressed as a
fraction, or ratio (like  3/5 ). Rational numbers cannot have zero as a
denominator.

This also means that all integers are rational numbers, since the
denominator can be expressed as 1.

An irrational number, on the other hand, is one that cannot be
expressed as a ratio, like p (PI).

 Z integers

An integer, i.e. a real number that has no fractional part. These can
be positive or negative.

A simple test in JavaScript might look like this:

function isInteger (n) {
  return typeof n === 'number' && n % 1 === 0
}

 N natural numbers

A natural number, a positive and non-negative integer. Depending on
the context and field of study, the set may or may not include zero,
so it could look like either of these:

{ 0, 1, 2, 3, ... }
{ 1, 2, 3, 4, ... }

The former is more common in computer science, for example:

function isNaturalNumber (n) {
  return isInteger(n) && n >= 0
}

 C complex numbers

A complex number is a combination of a real and imaginary number,
viewed as a co-ordinate in the 2D plane. For more info, see A Visual,
Intuitive Guide to Imaginary Numbers.

 function

Functions are fundamental features of mathematics, and the concept is
fairly easy to translate into code.

A function relates an input to an output value. For example, the
following is a function:

function1

We can give this function a name. Commonly, we use f to describe a
function, but it could be named A(x) or anything else.

function2

In code, we might name it square and write it like this:

function square (x) {
  return Math.pow(x, 2)
}

Sometimes a function is not named, and instead the output is written.

function3

In the above example, x is the input, the relationship is squaring,
and y is the output.

Functions can also have multiple parameters, like in a programming
language. These are known as arguments in mathematics, and the number
of arguments a function takes is known as the arity of the function.

function4

In code:

function length (x, y) {
  return Math.sqrt(x * x + y * y)
}

 piecewise function

Some functions will use different relationships depending on the
input value, x.

The following function f chooses between two "sub functions"
depending on the input value.

piecewise1

This is very similar to if / else in code. The right-side conditions
are often written as "for x < 0" or "if x = 0". If the condition is
true, the function to the left is used.

In piecewise functions, "otherwise" and "elsewhere" are analogous to
the else statement in code.

function f (x) {
  if (x >= 1) {
    return (Math.pow(x, 2) - x) / x
  } else {
    return 0
  }
}

 common functions

There are some function names that are ubiquitous in mathematics. For
a programmer, these might be analogous to functions "built-in" to the
language (like parseInt in JavaScript).

One such example is the sgn function. This is the signum or sign
function. Let's use piecewise function notation to describe it:

sgn

In code, it might look like this:

function sgn (x) {
  if (x < 0) return -1
  if (x > 0) return 1
  return 0
}

See signum for this function as a module.

Other examples of such functions: sin, cos, tan.

 function notation

In some literature, functions may be defined with more explicit
notation. For example, let's go back to the square function we
mentioned earlier:

function2

It might also be written in the following form:

mapsto

The arrow here with a tail typically means "maps to," as in x maps to
x^2.

Sometimes, when it isn't obvious, the notation will also describe the
domain and codomain of the function. A more formal definition of f
might be written as:

funcnot

A function's domain and codomain is a bit like its input and output
types, respectively. Here's another example, using our earlier sgn
function, which outputs an integer:

domain2

The arrow here (without a tail) is used to map one set to another.

In JavaScript and other dynamically typed languages, you might use
documentation and/or runtime checks to explain and validate a
function's input/output. Example:

/**
 * Squares a number.
 * @param  {Number} a real number
 * @return {Number} a real number
 */
function square (a) {
  if (typeof a !== 'number') {
    throw new TypeError('expected a number')
  }
  return Math.pow(a, 2)
}

Some tools like flowtype attempt to bring static typing into
JavaScript.

Other languages, like Java, allow for true method overloading based
on the static types of a function's input/output. This is closer to
mathematics: two functions are not the same if they use a different
domain.

 prime

The prime symbol (') is often used in variable names to describe
things which are similar, without giving it a different name
altogether. It can describe the "next value" after some
transformation.

For example, if we take a 2D point (x, y) and rotate it, you might
name the result (x', y'). Or, the transpose of matrix M might be
named M'.

In code, we typically just assign the variable a more descriptive
name, like transformedPosition.

For a mathematical function, the prime symbol often describes the
derivative of that function. Derivatives will be explained in a
future section. Let's take our earlier function:

function2

Its derivative could be written with a prime ' symbol:

prime1

In code:

function f (x) {
  return Math.pow(x, 2)
}

function fPrime (x) {
  return 2 * x
}

Multiple prime symbols can be used to describe the second derivative
f'' and third derivative f'''. After this, authors typically express
higher orders with roman numerals f^IV or superscript numbers f^(n).

 floor & ceiling

The special brackets [?]x[?] and [?]x[?] represent the floor and ceil
functions, respectively.

floor

ceil

In code:

Math.floor(x)
Math.ceil(x)

When the two symbols are mixed [?]x[?], it typically represents a
function that rounds to the nearest integer:

round

In code:

Math.round(x)

 arrows

Arrows are often used in function notation. Here are a few other
areas you might see them.

 material implication

Arrows like = and - are sometimes used in logic for material
implication. That is, if A is true, then B is also true.

material1

Interpreting this as code might look like this:

if (A === true) {
  console.assert(B === true)
}

The arrows can go in either direction = =, or both =. When A = B and
B = A, they are said to be equivalent:

material-equiv

 equality

In math, the < > <= and >= are typically used in the same way we use
them in code: less than, greater than, less than or equal to and
greater than or equal to, respectively.

50 > 2 === true
2 < 10 === true
3 <= 4 === true
4 >= 4 === true

On rare occasions you might see a slash through these symbols, to
describe not. As in, k is "not greater than" j.

ngt

The [?] and [?] are sometimes used to represent significant inequality.
That is, k is an order of magnitude larger than j.

orderofmag

In mathematics, order of magnitude is rather specific; it is not just
a "really big difference." A simple example of the above:

orderOfMagnitude(k) > orderOfMagnitude(j)

And below is our orderOfMagnitude function, using Math.trunc (ES6).

function log10(n) {
  // logarithm in base 10
  return Math.log(n) / Math.LN10
}

function orderOfMagnitude (n) {
  return Math.trunc(log10(n))
}

^Note: This is not numerically robust.

See math-trunc for a ponyfill in ES5.

 conjunction & disjunction

Another use of arrows in logic is conjunction [?] and disjunction [?].
They are analogous to a programmer's AND and OR operators,
respectively.

The following shows conjunction [?], the logical AND.

and

In JavaScript, we use &&. Assuming k is a natural number, the logic
implies that k is 3:

if (k > 2 && k < 4) {
  console.assert(k === 3)
}

Since both sides are equivalent =, it also implies the following:

if (k === 3) {
  console.assert(k > 2 && k < 4)
}

The down arrow [?] is logical disjunction, like the OR operator.

logic-or

In code:

A || B

 logical negation

Occasionally, the !, ~ and ! symbols are used to represent logical
NOT. For example, !A is only true if A is false.

Here is a simple example using the not symbol:

negation

An example of how we might interpret this in code:

if (x !== y) {
  console.assert(!(x === y))
}

Note: The tilde ~ has many different meanings depending on context.
For example, row equivalence (matrix theory) or same order of
magnitude (discussed in equality).

 intervals

Sometimes a function deals with real numbers restricted to some range
of values, such a constraint can be represented using an interval

For example we can represent the numbers between zero and one
including/not including zero and/or one as:

  * Not including zero or one: interval-opened-left-opened-right

  * Including zero or but not one: interval-closed-left-opened-right

  * Not including zero but including one:
    interval-opened-left-closed-right

  * Including zero and one: interval-closed-left-closed-right

For example we to indicate that a point x is in the unit cube in 3D
we say:

interval-unit-cube

In code we can represent an interval using a two element 1d array:

var nextafter = require('nextafter')

var a = [nextafter(0, Infinity), nextafter(1, -Infinity)]     // open interval
var b = [nextafter(0, Infinity), 1]                           // interval closed on the left 
var c = [0, nextafter(1, -Infinity)]                          // interval closed on the right
var d = [0, 1]                                                // closed interval

Intervals are used in conjunction with set operations:

  * intersection e.g. interval-intersection

  * union e.g. interval-union

  * difference e.g. interval-difference-1 and interval-difference-2

In code:

var Interval = require('interval-arithmetic')
var nextafter = require('nextafter')

var a = Interval(3, nextafter(5, -Infinity))
var b = Interval(4, 6)

Interval.intersection(a, b)
// {lo: 4, hi: 4.999999999999999}

Interval.union(a, b)
// {lo: 3, hi: 6}

Interval.difference(a, b)
// {lo: 3, hi: 3.9999999999999996}

Interval.difference(b, a)
// {lo: 5, hi: 6}

See:

  * next-after
  * interval-arithmetic

 more...

Like this guide? Suggest some more features or send us a Pull
Request!

 Contributing

For details on how to contribute, see CONTRIBUTING.md.

 License

MIT, see LICENSE.md for details.

About

a cheat-sheet for mathematical notation in code form

Resources

Readme

License

MIT License

Releases

No releases published

Packages 0

No packages published

Contributors 16

  * @mattdesl
  * @quinn-dougherty
  * @nshen
  * @cbrown132
  * @0xflotus
  * @swerwath
  * @chocolateboy
  * @Luxcoldury
  * @asmeurer
  * @mrdoob
  * @mdnu

+ 5 contributors

  * (c) 2021 GitHub, Inc.
  * Terms
  * Privacy
  * Security
  * Status
  * Docs

 

  * Contact GitHub
  * Pricing
  * API
  * Training
  * Blog
  * About

You can't perform that action at this time.
You signed in with another tab or window. Reload to refresh your
session. You signed out in another tab or window. Reload to refresh
your session.