Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

More Features #1

Open
5 of 8 tasks
mattdesl opened this issue Jun 29, 2015 · 17 comments
Open
5 of 8 tasks

More Features #1

mattdesl opened this issue Jun 29, 2015 · 17 comments

Comments

@mattdesl
Copy link
Contributor

The guide is not complete. More planned features:

  • cross product
  • tensor product
  • delta
  • dot product
    • common patterns like clamped dot product with angled brackets too specific I think
  • indefinite integral
  • ƒ - function
  • Heaviside function (step()) possibly too specific; already have sgn
  • common patterns like greek letters vs latin ?

And generally:

  • converting some complex/intimidating expressions into code
  • notation-to-code examples from real papers (e.g. graphics programming papers)
@mattdesl mattdesl changed the title Notations More Features Jun 29, 2015
@cihadturhan
Copy link

I didn't want to open a new issue. Instead, I'm adding here:

function clamp(a,b,c){
  return Math.max(b,Math.min(c,a));
}

function smoothstep(edge0, edge1, x)
{
    // Scale, bias and saturate x to 0..1 range
    x = clamp((x - edge0)/(edge1 - edge0), 0.0, 1.0); 
    // Evaluate polynomial
    return x*x*(3 - 2*x);
}
  • Angle conversions e.g. degree to radian
// Converts from degrees to radians.
Math.radians = function(degrees) {
  return degrees * Math.PI / 180;
};

// Converts from radians to degrees.
Math.degrees = function(radians) {
  return radians * 180 / Math.PI;
};
  • Spherical to cartesian etc
function sph2cart(vect) {
            //r, theta, phi
            var z = vect.x * Math.sin(vect.z);
            var rcoselev = vect.x * Math.cos(vect.z);
            var x = rcoselev * Math.cos(vect.y);
            var y = rcoselev * Math.sin(vect.y);
            return new THREE.Vector3(x, y, z);
        }
    };

@JavDevGames
Copy link

+1 for indefinite integrals

I'd also vote for the laplace operator

Inspiring guide so far!

@avdi
Copy link

avdi commented Jun 30, 2015

This is a super cool project.

Something that baffled me when first reading FP literature was the frequent use of "prime" notation: e.g. an equation that contained both a and a' and sometimes even a''. It took me a while just to figure out what this was called.

Also, in general I have trouble grokking something if I can't "read it aloud" in my head. So any guidance for how to say notation is greatly helpful for people like me.

@mattdesl
Copy link
Contributor Author

@cihadturhan cheers, I will consider those. I eventually hope to have another part of the repo that holds "practical examples" (aimed at graphics programming), and it might include turning equations into, say, GLSL built-ins like sign, step and smoothstep.

@avdi thanks for the feedback. See #5 which includes prime 😄

@JavDevGames
Copy link

Dunno if this might interest you, but I found this website the other day: http://visualgo.net/ and the way they present their explanations is makes it seem really simple to understand (though they could use a bit less pseudocode IMHO)

@tiborsaas
Copy link

Here's a huge list of math symbols:
https://en.wikipedia.org/wiki/List_of_mathematical_symbols

@daemonna
Copy link

daemonna commented Jul 1, 2015

i would like to see matrix algebra features like transpose, complex conjugate, etc.. as matrices are real big deal :) and don't forget there are also other algebras than Gibbs (Clifford, etc)...

@richjames0
Copy link

this is excellent - thanks!

i think it would be really helpful to see example (simple) implementations of the functions mentioned, such as dot, cross and determinant

@angererc
Copy link

angererc commented Jul 2, 2015

I like the project a lot. I especially like the idea of focusing on mathematical operators (which are easy to write but can be pretty involved to compute) and not whole algorithms because there are plenty of books describing algorithms. I always think of mathematical operators as small programs and if I don't have a corresponding program in my head I don't really understand the operator. Having had a guide like yours would have saved me a ton of time when I was younger.

I would love to see a "numerical math" section which presents operators such as integrals, derivatives, gradients and laplacians etc. because using numerics is how most of these things are implemented in practice (and it's often easier to understand I think)

As examples: given are the values of a function f(x) at discrete points in the form of an array.

  • The derivative f'(p) at grid point p is just the difference of its neighbors f'(p) = f(p+1)-f(p).
  • A laplacian is somewhat similar the average of all the differences between the surrounding points in n dimensions.
  • An integral is just the sum of the values which shows the similarity in the used signs: a large cursive S for integral sums and a large Greek Sigma for the summation operator.

@mattdesl
Copy link
Contributor Author

mattdesl commented Jul 3, 2015

@chmaruni Thanks for the feedback. Things with limits (derivatives, integrals, infinity) are going to be tough to translate into code. Discrete points might work for certain things... The same is done here and makes sense to me. 😄

@angererc
Copy link

angererc commented Jul 3, 2015

I agree, operators with limits, infinites and infinitesimals sometimes seem borderline magic and hard to grasp. That's why I think that seeing how they operate on discrete functions (aka arrays) is so helpful, because more often than not they are pretty trivial things with fancy names.

@angererc
Copy link

angererc commented Jul 3, 2015

@mattdesl interesting video. He is still solving the integral analytically however (ie using transformation rules to get rid of the integrals) which is not exactly what I meant but still interesting of course. If you have the values of the function on an evenly spaced grid you can for example usd the trapezoidal rule, see "numerical implementation" here: https://en.m.wikipedia.org/wiki/Trapezoidal_rule

@ghost
Copy link

ghost commented Jul 4, 2015

I would love to see a "numerical math" section which presents operators such as integrals, derivatives, gradients and laplacians etc.

I would love too.

Things with limits (derivatives, integrals, infinity) are going to be tough to translate into code.

Exactly because they're tough to translate it's necessary to show even a few examples to give people idea how they can understand it.

I agree, operators with limits, infinites and infinitesimals sometimes seem borderline magic and hard to grasp. That's why I think that seeing how they operate on discrete functions (aka arrays) is so helpful, because more often than not they are pretty trivial things with fancy names.

Totally agree!

@ghost
Copy link

ghost commented Jan 18, 2018

Can be cool if you create a branch with mathematical formulas that we use in Machine Learn ( Gini, entropy, gain, similarity, euclidian distance ... ) ^ - ^

@Gremyo
Copy link

Gremyo commented Oct 17, 2018

What do you mean delta, the laplacian or?

@idhamari
Copy link

This is what I am looking for :)
Here are my suggestions:

  • add matlab/octave, python examples as they are more used by scientists.
  • add computation geometry and image processing notations.

@kumarsoumya
Copy link

Mixed fractions such as

image

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests