What are
/r/desmos'
favorite Products & Services?
From 3.5 billion Reddit comments
The most popular Services mentioned in /r/desmos:
Desmos
Repl.it
GeoGebra
Mathpix Snip
Inkscape
Blender
ShareX
ezgif.com
imgbox
Overleaf
Convertio
PollUnit
Brilliant.org
VLC Media Player
The most popular Android Apps mentioned in /r/desmos:
The most popular reviews in /r/desmos:
This took longer to make than I'd like to admit, but I still had a blast creating it. In school, we recently began learning about optics. Naturally, I created a ray tracer in Desmos to solidify my optic knowledge.
If you are experience a lot of lag, simplify set enabled = 0 . This will spare Desmos from casting rays in the first place. If you happen to consider forty simultaneous rays as undesirable, simplify set SingleRay = 1 to limit the number of rays to one.
>!(yes I know this is technically not a full-fledged ray tracer but rather a ray caster with sugarcoating on top but raytracing sounds more glamorous and mainstream so there h8 the game m8)!<
---------------------
HUGE thanks to u/quantificator for bringing this graph to life. Regressions obviously played a huge role in finding the intercepts for the rays, so it's no surprise that his introduction enabled this graph to exist. (P.S: It turns out, finding intercepts using regressions can be controlled in a number of ways. ;) )
Many techniques were used to create this graph. I had to figure out how to...
- Automatically convert quadratics to vertex form (this consistently works, btw!).
- Simplify radicals in Desmos.
- Convert numbers to fractions.
- Prevent Desmos from dividing numbers.
- Fake the process of algebra.
THIS IS NOT PERFECT; far from it, if I'm being honest. Because of my approach, Desmos will often litter an "undefined" result when dealing with numerators too large. This is mainly because of how I dealt with fractions. Any numerator or combination of numerators that exceeds 9999 will likely cause Desmos to give up calculations due to the limit of lists.
Please let me know if there are any ways to improve the graph! I want this to be as optimized as possible, so any feedback will help me tremendously!
If you just enter a load of integers into the table of points and then set them to drag, you can move them into position assuming they're close to where you want them, kinda like this. Not sure if this is what you mean.
What an awesome residual hack.
Putting ?embed at the end of the url is a great way to hide the expression list -- and as a bonus, it locks the window from zooming/panning! I have a touchscreen, which made this really fun to play with: https://www.desmos.com/calculator/hztysvbmja?embed
Here is the link! Keep in mind that this is an early draft.
https://www.desmos.com/calculator/uxpfqbhtz5
LMK if you have any questions or suggestions!
I made a similar graph a few months ago with a less restricted corner position https://www.desmos.com/calculator/luqknbr1mx
You can find the crease line by taking the perpendicular bisector between the original position of the corner and the new location.
That is a solid sort of.
https://www.desmos.com/calculator/1kd7htayur
You can fake it with functions, but it gets pretty slow pretty fast and you also get 'definitions nested too deeply pretty quick.
I hope it works, It's a pretty limited workaround and I've been wanting proper iteration forever.
Just a tip, you don't need slider variables for points, you can just enter some numbers and then you can drag them around: https://www.desmos.com/calculator/huomu7n7fb
Here's the link to the graph: https://www.desmos.com/calculator/eswm4kf07x
​
Note: I noticed that you can actually index a list with another list by setting the upper and lower bounds of a sum to equal that list. Then, you can index the first list using the variable produced from your sum, and essentially produce all of the values in the first list using the second list as an input. Kind of a random trick, but you'll see it being used in the "Letters" folder.
I agree that recursive functions are sorely missed. Fortunately, DeMoivre's Theorem makes powers of complex numbers fairly easy to work with.
I made a quick Desmos example that shows one possibility.
You could try this tutorial: https://mathvault.ca/desmos-art-guide/
It looks pretty good.
If you're asking about literally getting text up you can label points https://www.desmos.com/calculator/3rzapt9wrs.
This is a recursive recreation of Newton's method for solving equations. By using a "fake" regression, you could trick Desmos into making regressions dependent on each other. Pretty nifty.
Desmos and JavaScript in general uses floating point and so for well defined cases like 1/0 it doesn't actually give an error but instead results in Infinity. Desmos sometimes uses Infinity in intermediate calculations to be able to resolve more equations than if it simply threw an error on the first occurrence. However, when the final result of an equation is +/-Infinty the output will stay undefined.
Also at some point the added support for the LaTeX \infinity, which you can get by typing infinity into the calculator. So instead of using an equation like 1/(a-1) you can more easily right a piecewise function like {y1=0: 0, ∞} which can be better modified to get the right conditions you want.
I have found something similar I have used for another graph. The only problem is once it is stopped it returns to the 0 position and not where it last left off of. The graph is here Graph!
A first attempt at an Anti-Cheat system dice rolling simulator.
https://www.desmos.com/calculator/k5bhmlxgp8
​
NOTE: Technically, you can still cheat by not letting go of the point during the "REVEAL VALUE?" prompt, but this can be eliminated by not revealing the value until you let go of the first slider and activate a second, final slider.
​
Let me know if you have any thoughts on how this could be improved!
Likewise, I'm open to any ideas about what larger projects this could be used for.
Once upon a time I worked out the pip positions for a 6-sided die. Not the most pretty code, but maybe you could salvage something: https://www.desmos.com/calculator/zdkopdbdn4
There's an optional piece to the conditional that may be what you want: {condition: result if true , result if false}
"Is undefined" is tricky in general (which is why desmos doesn't show removable discontinuities by default), but "Is defined" is sometimes easier: check if it equals itself! Demo graph: https://www.desmos.com/calculator/iu0ctyupc9
https://www.desmos.com/calculator/zuthhxwawe
Use {} to group the characters.
You can also copy any math notation and when you past, it'll past the LaTeX code you need.
Neat. Make sure you use g(x) in your other statements so that changing it once updates the picture. You might also want to just define a 4-argument complex multiplication function that spits out a point, https://www.desmos.com/calculator/zmc7l24k0l
It is indeed too bad that you apparently can't index into a point.
Whew, this one took a while!
Ever since I discovered you can use polygons to model surfaces in Desmos, I've been dreaming about using it to
simulate origami models.
Each of the 26 points has distinct a x,y, and z coordinate, which all evolve over time. I used piecewise equations and trig to calculate how these coordinates should change, then mushed it all together in stages(the ultimate animation has five stages of collapsing).
As always, let me know what you think! Feel free to suggest other cool 3D things to animate in the future.
-VTS
P.S: Here is the link: https://www.desmos.com/calculator/71ojp10sya
I thought I remembered your username from somewhere and I finally found it somewhere deep within my saved folder, so here is a special version created exclusively for your eyes: https://www.desmos.com/calculator/3yulj25lmc
No worries! There is a reason why I wrote 0 = at the beginning. It is used to indicate that the input is an equation. Whatever is contained within the brackets must equate to zero.
Take a look at this for a further understanding. https://www.desmos.com/calculator/olqxdyl9ml
Desmos has an API, https://www.desmos.com/api/v1.3/docs/index.html
You can get access to the Desmos.GraphingCalculator object at the main calculator site under the global name Calc, and use your Javascript console to interact with the calculator programmatically.
You can actually find exact solutions for these invariant points by find the roots of z=z^(2)+c, since this is a quadratic equation it means there are actually two such points for any given Julia set (except where the discriminant is 0, in this case c=0.25).
Dear u/AlexRLJones, This is by far the coolest thing I think I have ever seen in Desmos! You should definitely send this to Desmos and see what they think- who would have thought that Desmos could be turing-complete? I just realized that now that we can store states and stuff, Desmos can essentially do the same calculations that most computers can do- however, my mind is so blown right now that I can't really even imagine where to go from here. Making Microsoft word, perhaps? What about Galaga? Now that we can store previous states of things, we should be able to approximate the direction of moving points over time, so animated points can rotate according to which way they're traveling(create a slope function between their current position and their previous position as of 1 second ago). If you have any other ideas on stuff to make, feel free to shoot them along as well. You should definitely share this graph with others, though- it totally made my day!
Best, VTS
P.S: Here's a potential design for the cells in the simulation. Let me know what you think! https://www.desmos.com/calculator/2k4c7iakpm
I really like this graph and problem in general (of course introduced by Vsauce) so I tried to adapt it to 3D.
Here is the result: https://www.desmos.com/calculator/t7bre3iebq
Desmos has an in built argument function (atan2):
arg(x,y) = arctan(y,x)
Also I recently just made a graph on complex roots.
Your graph is quite interesting and I want to study it a bit further but I'm a little unsure of some of the things you mentioned. I know roots of unity form polygons and their sum is zero, but I don't see them in your graph. Also, by phase of the polygon, do you mean it's rotation? Is the line the partial sum of the roots? Are the points the powers of the roots? Sorry for not understanding.
>Thanks to the mod function, the calculator no longer uses lists of numbers, meaning it won't freeze up after you've given it a ridiculous amount of intervals.
Nice! Yeah, the list lag is real, but it does also depend how you use it. In your case, it's actually painting the inequalities that eats up all the resources. (Hide lines 17 and 18 and note the speed bump.) In that older version, each f_riemann call is evaluating for all of the L_ist entries and returning a full long list of outputs. Even if most of them end up being undefined, you've got a list of N elements coming back for each x-value the plotter decides to look at. In your new approach, the mod is letting you shift the curve to the relevant portion of the domain, and you just a single number back from your evaluation.
Here's a Riemann that uses polygons to paint that fill, cutting down on the evaluation demands: https://www.desmos.com/calculator/a4p32uhwjm
Update: Here's a prototype of a possible dice roller that implements your idea to use an animated slider.
https://www.desmos.com/calculator/0bcgacxgle
Do you have any suggestions for how this might be improved? I tried to make the randomizing thing seem organic and easy to use.
I was particularly happy with our discussion this year of Rectangle Area Curve and this untitled graph about over / underestimations.
This got me interested in looking into the console myself, noticed there is another way to change colours. You can change the six default colours to something else so you can reuse the same colour multiple times easier.
Calc.color.COLOUR = "#RRGGBB"
Just replace COLOUR with one of BLACK, BLUE, GREEN, ORANGE, PURPLE or RED.
And RRGGBB with their respective hex codes.
Example: #DesmosYellow
> What would your dream dark-theme be?
My all-time favorite dark theme of any app is the one from Blender with its soft shades and blue accents.
> What changes
For me the difference is contrast. I get eye-strain when I use my computer for longer periods, and bright colors and/or high contrasts makes me get eye strain fairly quicker.
This is very cool. I just started playing around with Desmos / Desmos Art. This is my first piece of art work.
We don't have matrices (and other advanced latex formatting) for labels, but if you know how big your window is you can cheat with some graph elements: https://www.desmos.com/calculator/fv5cdpgg3z
Love this idea!
​
Here is my submission: https://www.desmos.com/calculator/huzjwqmdrt (It's pretty messy).
​
I hard coded in all the segment locations and each segment just looks at its part of the number in the array to decide whether or not to turn on.
This does seem like a problem, it would suck if you have to count each symbol manually, although I'm sure what a solution would be.
If you're interested, with my second attempt I'm here, but I'm stuck with a bug where the last digit sometimes is incorrect but other times not.
Nifty. As for why \pm is recognized, Desmos draws on MathQuill to process LaTeX, so there's some lovely bonus symbols that can be assigned values. (My favorite: https://www.desmos.com/calculator/8vu1yvp7co)
The official word on what's supported though, is to stick with what's in the pop-up keyboard. There's a small chance that down the road there could be a change to the calculator that will make \pm no longer work out.
That's really helpful, making an ordered list of pairs of coordinates for the points.
I made this with it: https://www.desmos.com/calculator/oizz9q6ezk
The fundamental principle for these graphs is that I've defined a function that takes in a point in mod arg form and outputs another point based on those values. Using the function for a parametric curve yields very pretty results such as this one. To make it even more pleasing to the eye, I've done some fiddling around in The GIMP. Anyway, Enjoy!
Neat. Recommendations:
- Set the background grid lines to step 2 so that the minor grid lines will have step 1/2, to match the green grid
- Allow a < 1, and plot f(t, g(t)) from −10 to 10
- Move the definition of g to the top
- Pick a different color for the 'triangles' section, and maybe show the segments pointed at z and z^(2) in a different color/style or maybe only show those two.
Desmos comes with a set of example graphs for lines and parabolas that you can find by clicking on the menu icon in the top left of the calculator. You can use these to find equations matching those in the image. Example
In addition you can use restrictions to limit the domain or range of the functions using {} around each restriction. Example
(1-r)² + 2r(1-r)² + 3r²(1-r)² + 4r³(1-r)² + … = 1
(Segments in the diagram)
Then 1 + 2r + 3r² + 4r³ + … = 1/(1-r)²
One of the strangest calculus questions I've seen, but it evaluates to:
f(x) = π(1-cos(1-cos(cos(x)-cos(1-cos(1-cos(1-cos(x)))))))
Is seems to be a float point precision error in the summation, where it calculates the two values (kn and round(kn)) but because the fraction n can't be written in perfect accuracy in binary, when the two values are compared they different by a tiny amount (~10^-15) and the equality fails.
Why the occurs only during the summation and not during the list method I am unsure but could be to do with how they've implemented a system to interpret rational numbers as fractions.
If you want to write the formula as a summation you can still do so but accounting for a small error like this: https://www.desmos.com/calculator/hpd5iuv6hm
The first one might be counting every time kn = round(kn) - Its summing the count...so the first time it finds it it puts in 1 then the second one 2..but only when they are equal.
Not sure though..would need to spend more time. I can tell you they are not the same.
Whenever I do lists i always dump them out in a table to see what they are at at least initially. https://www.desmos.com/calculator/gn9oye8oj6
Thanks!
You can remove the limits by adjusting the slider limits - here is a graph I just made demonstrating the 4 different ways you can configure the sliders: https://www.desmos.com/calculator/wbjkvuoofb
Good luck!
You can iterate a single value through a function repeatedly by using a regression trick to define a value in terms of itself (x = f(x)) and you can use a counter to track/limit how many times you iterate.
https://www.desmos.com/calculator/fdmf8ofe4h
But I don't know any way to do this for the entire domain of the function.
it’s quite satisfying to watch in my opinion. if you want I made an updated version with a few more features. https://www.desmos.com/calculator/nokkhbguld
Yes, it does come in very handy, and not just for B.E. calculators! Here is another ( rather simple ) example of how it can be used within graphs in a clock I made.
I've changed the wave function to produce a square wave (upto 5 harmonics) and the Fourier Transform is simply amazing!
I'm actually studying Multivariable Calculus right now. Funny enough, I am also trying to figure out how to animate 3D motion on Desmos, but I can only create certain rotations of a unit sphere. https://www.desmos.com/calculator/ohezxzmid7
Not sure if this is what you're looking for but you can use regressions to find solutions to equations (like intersections) and also use them to store values: https://www.desmos.com/calculator/s9y3vcatbz
Floating point errors maybe? Sliders will stop behaving correctly if they can't reach the value they want due to constraints on computer numbers *~*
It still exists, technically. Use a '~' when writing your equation. Replace any x's or y's with other letters like so: https://www.desmos.com/calculator/q0cd8taqnh
I used another desmos program to get the desired coefficients. I simply broke my desired shape into a parametric equation, r(t)=<x(t), y(t)>, where both x(t) and y(t) components are piecewise functions. x(t) represented the real component and the y(t) represented the imaginary component.
In the video, the formula 3b1b used to find a specific coefficient was the integral of f(t) * exp(2nπit) from t=0 to t=1. To convert this complex function into vector form, f(t) was replaced with (x(t)+i* y(t)) and exp(2nπit) was replaced with cos(2nπt)+i* sin(2nπt). When multiplied out and simplified, you get 2 integrals: The first gives you the real component of your coefficient and the 2nd gives you the imaginary component. Here's the desmos program to calculate the coefficients: https://www.desmos.com/calculator/hogxty7qdu Here's an old animation I made of a fourier animation of a square: https://www.desmos.com/calculator/jb6a5flbf0 Note: This animation is obsolete and slow compared to my newer ones.
Dang. The best 3D animation I could make without looking up for tutorials is making the latitude lines of a sphere rotate: https://www.desmos.com/calculator/vnsotur2si Where do you learn how to do these rotations? Are you using quaternions or Euler angles? I would like to know.
This is just a rip from this ine here (https://www.desmos.com/calculator/imazvy40oz).
Can anyone point me in the right direction of the derivations of the guts section?....are they all just derivations of the addition formula....x' = r × cos(α) cos(β) - r × sin(α) sin(β)
Here's the link to an updated version:
https://www.desmos.com/calculator/2zmup9zhqh
I think i know what went wrong. The radius is too big, so it kinda sticks through the sinoid. If you reduce r, it should work better!
Desmos is great and all, but it can't do indefinite integration like Symbolab or Wolfram... until now! Indefinite integration.
(Is "engineering math" okay? I'm a fan of numerical methods and this was a fun challenge)
You can iterate a single value through a function repeatedly by using a regression trick to define a value in terms of itself (x = f(x)) and you can use a counter to track/limit how many times you iterate.
Your g(x) function is pretty close; I'm not sure why it doesn't work. What you could do instead is reciprocate the slope and just test for that. Vertical lines should have denominators of zero. https://www.desmos.com/calculator/0hnmhvaqrt
Here’s a slightly refactored version of the original, https://www.desmos.com/calculator/bycpg52hho
One advantage of the one in the previous comment is that it doesn’t break down for the straight line case.
Here you go :)
The graph works when the points' x-coordinates have the same sign. The shading and legs are weird/wrong when the they have different signs, but I wasn't sure what behavior you wanted there.
Feel free to ask me any questions about the graph and suggest improvements :)
>moving, hittable enemies
it will need some modification, but should be easy.
>A working LR joystick with a toggle-able firing option
someone already did a joystick, haven't found it yet, and the firing option isn't very hard.
>Title screen and a high score display
there's gonna have to be a mostly blank loading screen in there, as for high score, slider memory tricks should work.
Ha, are you spying on my workflow?? I needed the center of that circle for some work I was doing last week, and totally gave up on simplifying: https://www.desmos.com/calculator/lgqa4ypnow
This is ridiculously neat.
Allow me to introduce you to my favorite friend, arctan(y,x)! I recommend it for cleaning up the ever-so-tiny bug when the foot is directly below the knee: https://www.desmos.com/calculator/juwhpv1nej (lines 65-67)
We can't really answer the question as stated, because both x and y are "free variables" -- there's no connection between them, so whatever power of x you looked at wouldn't have a connection to y. It wouldn't be less than y, nor would it be greater than y. It would just... be.
What we can do is compare x^n with some other thing that depends on x. I'll be super fancy and leave it totally general -- I don't know how exactly the thing depends on x, but I'll give it a name anyway: f(x). So now your question becomes "How do I find the largest power of x that is smaller than f(x)?" Or, in math-speak: "What is the largest value of n where x^n < f(x)?"
Tweak number 1: let's change n to be y. We aren't using the name y yet, so it's free to use; and it doesn't have the same implication of an integer value. I might see x^n and think I only care about things like x^3, x^5, x^107; but with x^y is could be anything, like x^2.5 or x^3.14159...
Tweak number 2: We're going to need to pick an f to get something to visualize in desmos. I think f(x) = x*sin(x) is a really cool function, so let's go with that.
Result: https://www.desmos.com/calculator/2icqtemfpr. In each of those green regions, if you push the y-value onto the exponent of the x-value, you'll get a number which is smaller than x*sin(x). Try different f(x) choices, see what you can make!
Niiice. Your R_2 "random" function has a nice advantage over the new random function: it doesn't spit out a list, which means the plotter only needs to graph one function instead of s^2. I'd be interested to hear if you can find a way around that. Here's my 10Print as a demo of using random on a list: https://www.desmos.com/calculator/cru4jnva4i
I wasn't really sure how "ℓ" was to change but here's a structure to increase ℓ when all the all the previous requirements have been met:
https://www.desmos.com/calculator/77acwg3zm6
This is a great idea. Here's my implementation of it: https://www.desmos.com/calculator/svbjgqjcny
It doesn't suffer from the issue of the changing direction because each cardinal direction gets a separate variable that only increases but it still inherits the large issue from my previous post that when you pause the sliders they jitter about. It also has the potential problem of the sliders reaching their maximum value and resetting to 0 but I used u/Minerscale's animation period trick to make them loop every 10 hours so it probably won't be an issue.
This exploit using regressions is super useful. I prefer using piecewise expressions when testing for equality because they're easier to write. Either way I created some more examples using this:
Slider Lock The slider pauses at a predetermined value only when another variable is set and resumes when it is released.
Slider Pause (Basically what u/Redguy05 was asking for) The slider pauses at its current value when another value is set and resumes when it is released.
However, there are some bugs with the second one
- If the slider is set to oscillate between the two values (instead of looping) then when unpausing it, it will start moving again in a seemingly random direction from which it was moving in previously.
- When the slider is paused it will jitter between two very close values (say 0.1 and 0.11), that is until you scroll up or down on the expression list! I don't know if this behaviour is consistent but it seems very strange that scrolling on the expression list would have any affect on the result of calculations.
Dear u/swoyer,
Hope your memorial day weekend has been going well so far.
I played around a little more with your parameters glitch and figured out a way to make a slow timer run only once, before stopping at a designated spot:
https://www.desmos.com/calculator/scrn3hixfg
This might be kind of fun to use in a timed game, or some sort of race; idk.
Anyway, I just wanted to let you know that your discovery is being put to good use!
Best wishes,
-VTS
I've actually found a basic way of doing super rudimentary collisions for a WASD adventure game, but I haven't completely expanded on it yet to include more complex collision shapes. Currently, in this build, you can't pass into the grey region on the right:
https://www.desmos.com/calculator/efb4ponajd
Hope this helps.
> GIFsmos is a web app for creating animated GIFs from Desmos graphs.
Paste your desmos graph link in the expressions bar.
Set your resolution and frame rate.
Change the slider settings to your desired variable and bounds.
Click capture. Generate GIF. Download. Profit.
You can always have sliders on screen I found a good way of doing that it just takes a while. I'll send my graph with the sliders. https://www.desmos.com/calculator/nwxx2rdajm . But yea that wouldn't be that bad.
I did end up making the thing I was trying to make, using some stuff I found on Wolfram MathWorld. Check it out!
https://www.desmos.com/calculator/fjzegug3w7
Also I'd love to find out where the phase of the center of the basic p-sided polygons here comes from - look at the points on the line - each is the sum of p consecutive consecutive powers of a constant multiple of the p-th root of unity, a sort of center to the p-sided polygon they form (though with the right choice of p and q, it ends up actually being outside said polygon).
If that multiple is 1, the spiral collapses into a circle and all those points become just one, the circle's center. But if not, regardless of what multiple you choose, the line between those centers is constant for a given choice of p. It's interesting... I'm sure someone has explained it but I'd love to know the relationship between the slope of that line of centers and p.
You can emulate complex numbers by using points as parameters to functions by treating the x component as the real part and the y component as the imaginary part.
Then you have to write some simple functions in terms of those, such as add, multiple, divide, log, etc.
Then you can combine these functions together to make more complicated complex functions.
Like this you can then iterate a function on itself ( f(f(f(f(f(z))))), etc. ) like this, but it quickly reaches desmos' limit in terms of function complexity and gives up. Actual recursion has a similar issue where it becomes exponentially more complex to compute the more recursive layers there are especially when it's computing for a whole range of values in a plane simultaneously. However, a lot of recursive function can be converted into an iterative form that can usually be solved with summations and products which desmos can handle much easier but this does take more work when trying to create them.
I think it would be difficult for them to implement this but I would like to see what they could come up with.
Now that I've done some editing, I was able to improve the trapezoidal rule calculator. One thing beneficial about the mod function is that it repeats forever. Just examine the graph of mod(x, 1)!
​
I was able to use the mod function to linearly connect each point of interest in the function, giving the "jagged" shape that the trapezoidal rule produces. Each time the function ranges across an interval of delta x, the mod function performs one cycle of its range.
​
Here's the improved calculator. If you want to know what I'm talking about, scroll down to the "f_riemann(x)" function
​
Nicely done! You got me wondering about the period of a Lissajous -- how long it would take to get back to its starting position. Here's a graph that looks for the gcd of a and b to figure that out. I had to adjust your step size to be increments of 0.1, so I would know for sure how many decimal places they could have: https://www.desmos.com/calculator/udxemwccqu
This also shows off how to modify the domain for your parametric. You used cos(254*pi*a*t) and a domain of 0<t<1, which is equivalent to cos(a*t) with a domain of 0<t<254*pi. Most of the time I prefer a domain from 0 to 1, but here it felt right to extend that for the full period.
Ahh, now I see what you mean. You're right; cutting off the secondary ray would require a THIRD point of intersection. Desmos is laggy enough already, so this would be a big no no.
However, there is a solution to your problem, u/CloneAssassin. I personally find it undesirable, but it might be what you are looking for. Graph
x^(x) is defined for x ≥ 0 but when the base x is negative, it's only define for some rational powers in the form p/q. If q is odd then there is a real solution because we're finding an odd nth root (e.g. cube root, which works for both even and odd numbers because odd^3 is still odd and even^3 is still even), but if q is even (e.g. 2) then there is only a real solution if the base is positive (otherwise it would be imaginary) which can only be achieved for negative bases if we first index them by an even power (p) but if p and q are even then they are not co-prime and can be cancel to a simpler fraction.
​
tl;dr can take even real roots of negative numbers
​
https://www.desmos.com/calculator/lpdgyb9jvu
​
If you take the absolute value of the base you can see the curve continuously. As for why you get this discontinuous plot, desmos probably converts some of the real values on the axis into rational numbers so that it can get exact values for certain points on the curve (and then those where q is odd it evaluates as real, those where q is even are imaginary and aren't draw and those where desmos can't convert the decimal to a fraction it also doesn't plot). A similar thing happens with trig functions, are multiples of pi they hard code the values so that you get exact values even though they can't store pi exactly and calculations with approximations might lead to answers like 0.00000001. (sorry for rambling)
There is no way to get a list of solutions, though you can coerce Desmos to find zeros using regression. https://www.desmos.com/calculator/cfif655bk8
It's fairly brittle though, because the variables that you get as solutions can get redefined elsewhere without any error warnings.
Thx, it would be cool to generalize it to a wider range of shapes. Maybe something along the lines of a reaction diffusion type pattern. Similar to the blobby shapes in this image: https://i.imgur.com/r00paXp.jpg
I really like the abstract art by Jean Arp that often features such aesthetically pleasing biomorphic shapes.
Inspired by @arjanvandermeij
Each of the constituent triangles is comprised of 8 triangles which correspond to the bits of a byte. Using the fact that the sums of the odd integers are squares, there are 256 of these triangles which represent each of the possible numbers that can be written in 8 bits, then each a iterated through all combinations.
If you want to write a parametric equation put the coordinates in like a point ( X(t) , Y(t) ) and use t as the parameter.
Then you can change the domain of the parameter below the equation.
https://www.desmos.com/calculator/o22c4vxrip
Btw, x=cos2t, y=sin3t is a Lissajous curve.
Ahhhhh so good!!! The pitch and yaw are clean and easy to work with, and the little details on the arm are so delightful.
​
I noticed each point has the same input expression. You can wrap that all up in a single function (I like the name T_hreeD) to make life a little easier. Demo, with two additional tweaks: https://www.desmos.com/calculator/vc2ts9mlcc
- I rebuilt the box using the
polygoncommand. (It's slightly faster for the calculator to draw connected endpoints and polygons than parametric paths. This graph doesn't really need it, but just in case you have more complicated things in the works..) - I swapped out the circles around the sliders for parametric paths, to prevent the coordinate trace from showing up when you accidentally click on the border.
Unfortunately, the Desmos team has restricted MathQuill so that it doesn't render certain math. You can check out the experimental matrix calculator at https://www.desmos.com/matrix to see if it might be useful.
You could try using lists as parameters. For example, you could have a list of 3 items, the first two are parametric equations for a line, and the third item is a number. You could have a function which added the third item onto the first two items and then returns all three as a list again. You could do repeated applications of the function like f(f(f(f(List)))). Then you would need another function to convert the list into a point so it can be rendered.
You can make transformations by using a point as a parameter of a function that returns a point and then accessing each coordinate using .x & .y e.g. f(z)=(z.y,z.x) this reflects the point in the line y=x You can then also pass in a parametric equation the transform am entire curve. Example graph: https://www.desmos.com/calculator/cfqj5ferfs
I can't seem to crack the Fourier Transform code, though... I have https://www.desmos.com/calculator/wchopxib3x, which I expected to be able to trace the green points I've plotted, but I must be missing something in those formulas because it's nowhere close to being right!
This is really cool. I had to tear it apart and piece it back together to see what was going on -- here's my commented reconstruction, for anyone else interested: https://www.desmos.com/calculator/xkjopmbi4k
Two more views of this one-to-one correspondence:
showing where equally spaced points on the unit circle go as the unit circle rotates: https://www.desmos.com/calculator/dz1dba22au
going back and forth between equally spaced points on the (non-rotating) unit circle and their images on the x-axis https://www.desmos.com/calculator/4othbepmjh
Nice. I'll point out that if you add one more restriction in line 2 you can force the iris to stay inside the boundaries. https://www.desmos.com/calculator/belxbjdbbn
First attempt. https://www.desmos.com/calculator/gvz48rbjul
Only display numbers 0-9.
It's somewhat unclear in instructions whether the display should feature/support multiple digits, although in my next attempt I want to try add that anyways.
You can just change the bounds on t₀, which is the time in seconds. By default I have it to cycle through a whole day, but the sliders in desmos can only move so slow.
Here, I made a new one with a table to adjust the start and end times from a table in digital format.
https://www.desmos.com/calculator/eljqlzbmvn
I gave making this a go myself. I got it down to 4 logical lines (one for creating a circle, 2 for drawing the hour marks and one for drawing the second hand) and 3 lines for defining variables.
Here is an even simpler solution (albeit just a modification of yours taking advantage of a feature in desmos).
You can use: polygon(x1,y1) for a list of points (x1,y1) to create any polygon.
Here is an even simpler solution.
​
The keys are:
- the vertices lie on the unit circle
- parametrization of a line segment from (a,b) to (c,d) is (a,b)t+(c,d)(1-t) on the interval t in [0,1]. For desmos you have to put this in the form (a*t+c*(1-t),b*t+d*(1-t))
If you don't care about colors, it is just as easy to use list to make all rotating regular polygons.
Here is that one. d=angle of rotation, n=number of sides