Hi,
I posted this accidentally in programs - My apologies.

I don't know how best to present the code that I have already. I am creating math chords inside a circle - It's for a simple cound reactive experiment. A chord is a line that connects two points of a circle and always stays within that circle (I think at least):

http://www.mathopenref.com/chord.html

I did this simply by drawing lines between points that move around the circle.

The code for the class that contains the point (Pvector) that moves around the circle is below.

But first I wanted to put my question forward which is that I want to attempt to make perpendiculars to the chord as is demonstrated here:

http://demonstrations.wolfram.com/PerpendicularsToAChord/

The code is there and the equation, and a demo of the movements it creates (like pistons) but unfortunately this is way way way over my head or at least I think it is. I wondered if anyone has any clue or advice as to how I would tackle this and turn it into processing code.

thank you so much.

the current class code for a Pvector object moves around the circle circumference is here: (in the main code tab I join a number of these Pvectors up using beginShape and endShape and lines that use the x and y values of the pVector objects).

Code:

class Tortoise{
 float radius;
 float x; float y;
 float scalar;
 float theta;
 float cenX; float cenY;
 PVector v;
 
 Tortoise(float irad, float ix, float iy){
   radius = irad; x = ix; y = iy;
   scalar = 375;
   theta = 0.0;
   cenX = width/2; cenY = height/2;
   v = new PVector(x,y);
 }
 
 float[] components(float scalar, float bearing){
   float[] comp = new float[2];
   comp[0] = scalar * sin(bearing);
   comp[1] = scalar * cos(bearing) * -1;
   return comp;
 }
 
 void change_bearing(float dTheta){
   float raw = theta + dTheta;
   theta = raw;
 }
 
 void turn(int KC, float turnRate){
   float[] nCoords = new float[2];
   if(KC == LEFT){change_bearing(-turnRate);}
   else if(KC == RIGHT){change_bearing(turnRate);}
   nCoords = components(scalar,theta);
   x = cenX + nCoords[0];
   y = cenY + nCoords[1];
   v.set(new float[] {x,y});
 }
 
 float getX(){return x;}
 float getY(){return y;}
 float get_pvector_theta(){return v.heading2D();}
 
 void paint(){
   stroke(255,0,0);
  // ellipse(x,y,radius,radius);
 }
}

he posted it two times, i deleted the other post.

If I've understood the website correcly it looks like the source code you link to is for Mathematica...  I'm not familiar with that but it doesn't look like there's much useful code there as it's using Mathematica specific methods.

Looking at my handy Useful Mathematical & Physical Formulae book (stupid Flash based site so I can't link to it directly, but you can browse it and some other interesting titles online*) I see that "A line perpendicular to another of gradient n will have gradient = -1/n".  I bet there are plenty of people on this forum who'll laugh that I had to look that up, but my memory is used to store origami folding sequences, not mathematical formulae

Anyway - if you can get the angle of your chord (try atan2 it should be easy enough to display another line perpendicular to it...  Looks like an interesting project to turn into a Processing sketch!


* Sorry - I know it's probably bad form to plug a product on here, but I have no connection to them except that they have some nice little books on offer; as well as some odd hippy titles...

I just thought it over, but indeed this problem isn't really processing. It's math. Good old basic trigometry & math.

I guess the problem is that these perpendicular lines have to intersect those A and B points at 0 and Pi like in the Wolfram example??

Hi blindfish,

Thanks you so much for that! It is so helpful! (Also I'm very impressed at the Origami figure ).

I would have been seriously lost if you hadn't helped me with that!
I will obviously reference you and credit you in the sketch when it's finished. I will post the final piece here or to your email address if you prefer. It's only a small personal project but thank you so much for the help!