### Inverse Circles ☀️

Inverse of Circles 🌘

```// You can find the Turtle API reference here: https://turtletoy.net/syntax
Canvas.setpenopacity(.7);

const grid = 5;

// Global code will be evaluated once.
const turtle = new Turtle();

var size = 200 / grid;

// The walk function will be called until it returns false.
function walk(i) {
var l1 = getRandomPoint(1);
var l2 = getRandomPoint(-1);

var intersections = [];
//var O = [0, 0];

for(var j = 0; j < grid * grid; j++) {
var x = j % grid;
var y = j / grid | 0;

var M = [((x + .5) * size) - 100, ((y + .5) * size) - 100];

var D = [l2[0] - l1[0], l2[1] - l1[1]];
var O = l1;

// If you are in 2D vector form the equations above can be represented as vectors by using
// origin O and direction of a ray D, where |D| must be strongly positive for the ray to
// intersect the circle. Let's say that the circle center is at position vector M and its
// radius is R. First, you need to define the vector from the center of the circle being M
// to the ray origin O:
//
// OM = O - M (O and M are position vectors)
var OM = [O[0] - M[0], O[1] - M[1]];
// In vector form you can define the quadratic equation coefficients like follows ( ^ means
// to the power of, dot means dot product between two 2D vectors, |VECTOR| means length of
// vector ):
//
// A = |D|^2
var A = vecLength(D) * vecLength(D);
// B = 2 * D dot OM
var B = 2 * dot2d(D, OM);
// C = |OM|^2 - R^2
// Now we can calculate the discriminant: Q = B^2 - 4*A*C
var Q = (B*B) - (4*A*C);

if(Q > 0) {
// If the given value is negative, there is no intersection if the value is zero, you have
// one root and one intersection as two roots for two intersection points. Store the value
// of G = 1/(2*A) in a variable it will become in handy later. Now calculate the determinant
// Q = G*sqrt(Q) and update the value of B = (-B * G)
var G = 1 / (2*A);
Q = G*Math.sqrt(Q);
B = (-1 * B * G);
// Now we are ready to calculate the intersection points. Let's call them P1 and P2 where we
// will have an equation as follows where B and Q are number scalars:

// P1 = D * (B + Q) + O
//var p1 = [(D[0] * (B + Q)) + O[0], (D[1] * (B + Q)) + O[1]];
//var p1 = addVec(multiplyVec(D, B+Q), O);
intersections.push(B+Q);
// P2 = D * (B - Q) + O
//var p2 = [(D[0] * (B - Q)) + O[0], (D[1] * (B - Q)) + O[1]];
//var p2 = addVec(multiplyVec(D, B-Q), O);
intersections.push(B-Q);
// The closest intersection point to the ray origin is P2 and the distant one is P1
//line(l1, p2);
//line(p1, l2);
} else {
//line(l1, l2);
}
}

var points = [l1];

intersections.sort(function(a,b) { return a - b;});
for(var j = 0; j < intersections.length; j++) {
}
points.push(l2);

for(var j = 0; j < points.length; j = j + 2) {
line(points[j], points[j + 1]);
}

return i < 200;
}

function getRandomPoint(side) {
//var pt = 400 * Math.sin(Math.random() * Math.PI * 2);
var pt = 400 * Math.sin(Math.random() * Math.PI);
if(pt < 200) {
return side < 0? [pt - 100, -100]: [-100, pt - 100]; //top: left
}
return side < 0? [100, pt - 300]: [pt - 300, 100]; //right: bottom
}

const line = (p1, p2) => {
turtle.jump(p1[0], p1[1]);
turtle.goto(p2[0], p2[1]);
}

function dot2d(v1, v2) {
return (v1[0] * v2[0]) + (v1[1] * v2[1]);

}

function vecLength(v) {
return Math.sqrt((v[0] * v[0]) + (v[1] * v[1]));
}

function multiplyVec(vec, multiplier) {
return [vec[0] * multiplier, vec[1] * multiplier];
}