var Px = Cx.Point;

var p = Px(x,y);
p.x  p.y

p.set(x,y);   // Modify inplace
p.set(point); // p := point
p.clone();    // return Px(p)
p.isEqual(point);    // return p == point
p.isNear(point,eps); // return p ~= point
p.isZero();          // return x == 0 && y == 0
p.add(point);            // p += point
p.substract(point);      // p -= point
p.scalarMultiply(alpha); // p *= alpha
p.sm(alpha);             // Shortcut for scalarMultiply
p.translate(offset);      // p += offset, same as add
p.translate(dx,dy);       // x += dx, y += dy
p.translated(offset);
p.translated(dx,dy);
p.transform(transform);   // p := transform.apply(p)
p.transformed(transform); // return transform.apply(p)
p.toSVG();       // return 'x y'
p.toXmlString(); // return 'x y'
p.textualize();  // return 'x y'
p.toCore();      // return { X: x, Y: y }
p.norm2();         // return x2 + y2
p.norm();          // return sqrt( norm2 ) 
p.normalize();     // p := p.normalized()
p.normalized();    // return p / norm
p.perpendicular(); // return orthogonal vector
p.confined(bounds);
p.confined(lx,ly,hx,hy);
p.confine(bounds);
p.confine(lx,ly,hx,hy);
p.angle();     // return angle with respect to the x axis
p.angle_rad(); // return angle in radians

Px.areEqual(pa,pb);         // return pa == pb
Px.fromXmlString(cdlPoint); // 'x y' => Px
Px.fromCore(pointModel);    // {X,Y} => Px
Px.distance(pa,pb);  // return euclidean distance between points
Px.distance2(pa,pb); // return squared euclidean distance
  
Px.minus(p);                // return -p
Px.add(pa,pb);              // return pa + pb
Px.substract(pa,pb);        // return pa - pb
Px.scalarMultiply(p,alpha); // return p * alpha
Px.sm(p,alpha);             // Shortcut for Px.scalarMultiply 
Px.dotProduct(pa,pb);       // return pa * pb
Px.crossProductZ(pa,pb);    // return pa ^ pb
    
Px.interpolate(pa,pb,t); // return pa * t + pb * (1-t)
Px.isInsidePolygon(point,polygon);

var Mx = Cx.Matrix;

var m = Mx(s00,s01,s10,s11, dx,dy);
m.s00  m.s01  m.dx
m.s10  m.s11  m.dy

m.apply(point); // return m * point
m.apply(x,y);   // return m * Px(x,y)
m.clone(); // return Mx(m); 
m.isEqual(matrix); // return m == matrix
m.isNear(matrix,eps); // return m ~= matrix
m.isIdentity();
m.isAlmostIsotropic(); // Only rotation and isometric scaling 
m.appended(matrix); // return m * matrix
m.determinant(); // return s00 * s11 - s01 * s10
m.scaleFactor(); // return sqrt(abs(determinant)) 
m.angle(); // return rotation angle
   
m.invert();
m.inverted(); 
m.toCssString(unit);  // return 'matrix(s00,s01,s10,s11,dx unit,-dy unit)'
m.toMatrix22String(); // return 's00 s01 s10 s11'
m.toMatrixString();   // return 's00 s01 s10 s11 dx dy' 
m.textualize();       // return 's00 s01 s10 s11 dx dy' 
m.toCore();           // return { S00, S01, S10, S11, DX, DY }

// Only for matrix22
Mx.add(m1,m2);                   // return m1 + m2
Mx.substract(m1,m2);             // return m1 - m2
Mx.scalarMultiply(matrix,alpha); // return matrix * alpha

Mx.sm(matrix,alpha);             // scalarMultiply shortcut
Mx.multiply(ml,mr);              // return ml * mr
Mx.concat(m1,m2,m3,...);         // return m1 * m2 * m3 * ...
Mx.invert(matrix);               // return matrix ^ -1

Mx.translate(offset);               // return translation matrix
Mx.translate(dx, dy);               // return translation matrix
Mx.scale(sx, sy, deg);              // return scaling matrix
Mx.scaleFrom(point, sx, sy, deg);   // return scaling matrix
Mx.rotate(deg);                     // return rotation matrix
Mx.rotateAround(point, deg);        // retrun rotation matrix
Mx.shear(sx, sy, deg);              // return shear matrix
Mx.shearAround(point, sx, sy, deg); // return shear matrix
Mx.transformAround(point, matrix);  // return general matrix

Mx.stringToMatrix22(string); // 's00 s01 s10 s11' => Matrix
Mx.fromCore(m); return { S00, S01, S10, S11, DX, DY } => Matrix

var b = Cx.Bounds(lx, ly, hx, hy);
b.lx  b.ly  b.hx  b.hy

Cx.Bounds.fromBox(box);     // { x, y, width, height } => Cx.Bounds
Cx.Bounds.fromXmlString(s); // 'lx ly hx hy' => Cx.Bounds
Cx.Bounds.fromCore(m);      // { LX, LY, HX, HY } => Cx.Bounds

Cx.Bounds.ofPoints(points); // return points bounds
Cx.Bounds.ofPointsAfter(points,transform);
Cx.Bounds.ofThings(things); // return things bounds
Cx.Bounds.ofThingsAfter(things,transform);

Cx.Bounds.overlapPercentage(ba, bb)
Cx.Bounds.horizontalOverlapPercentage(ba, bb)
Cx.Bounds.areOverlapping(ba,bb)
Cx.Bounds.intersection(ba, bb)
Cx.Bounds.union(boundsArray)

var f = Cx.Frame(p0,p1,p2,p3);
f.p0  f.p1  f.p2  f.p3

f.clone();
f.isEqual(frame); // return f == frame
f.bounds();
f.center();
f.width();  // return distance(p0,p1)
f.height(); // return distance(p0,p3)
f.width2();  // return distance2(p0,p1)
f.height2(); // return distance2(p0,p3)
f.minSideLength2();
f.translate(dx,dy);
f.translated(dx,dy);
f.transform(t);
f.transformed(t);
f.interpolate(ax,ay);
f.toXmlString();
f.contains(point);
f.extend(olx,oly,ohx,ohy);
f.extended(olx,oly,ohx,ohy);
f.angle(); // p0 p1 angle

Cx.Frame.fromRect(x,y,width,height);
Cx.Frame.fromBounds(bounds)
Cx.Frame.around(center,width,height);

Cx.Frame.fromXmlString(s); // 'p0x p0y ... ' => Cx.Frame
Cx.Frame.areOverlapping(fa,fb);
Cx.Frame.overlapPercentage(fa,fb);