/*

<?xml version='1.0' standalone='yes' ?>

 <script>
 
	<name>Trajectories and Curves</name>
	
	<author>Kevin Zwolf/Zwo:lf (Spiel Associates) after Ben Soares (from ed.ac.uk)... John O'Connor... after Imhotep</author>
	
	<version>0.1.3</version>
	<beta>1</beta>
	
	<date>October 12 2006</date>
	
	<description>Early (but not earliest) Draft of Script for 3D Trajectory and Curve 'rewriting/networks' experiments</description>
	
	<dedication>W.Tara.dedication.grant()</dedication>
	
	<copyrighTrace>copyright (c) 2006, Kevin Zwolf/Zwo:lf</copyrighTrace>
	
	<userSiren>...this script is 'extremely' Beta B U T works fine...</userSiren>
	
	<authoRequest>
	
	on reading this notice, please mail Kevin Zwolf/Zwo:lf the word 'traces', using: 
	
	kevinzwolf 'via' ('via' meaning '@') users.sourceforge.net			
	
      </authoRequest>

	<comment>
traces: (The) TRajectory Ampersand CurvE (or Curve (continuously) Evolving) Script
	On reading this notice, please mail Kevin Zwolf/Zwo:lf the word 'traces', using: 
	
	kevinzwolf 'via' ('via' meaning '@') users.sourceforge.net			
	

	</comment>
</script>

*/

/*
        
	'this' script traces is a D R A F T, do play as you please B U T if you see faults (especially on the (it's not) OO side), then do think
	
	about contacting me.. E S P E C I A L L Y if you're looking for a 'scripting'/3D/Animation project for School/Uni'..
	
	I've got other 'fish' on my mind, so 'clean up' & 'development' associates will be welcomed.. & yes, the address is a genuine one.....
	
	& yes, Zwolf/Zwo:lf is a nomDePlume (or nomDejEdit)...
	
*/

import java.math.*;

curvesNameList = new BList(new String [] {
"Astroid",
"Cardioid",
"Catenary",
"Cayley's Sextic",
"Cissoid of Diocles",
"Cochleoid",
"Conchoid",
"Conchoid of de Sluze",
"Cycloid",
"Devil's Curve",
"Double Folium",
"Eight Curve",
"Ellipse",
"Epicycloid",
"Epitrochoid",
"Equiangular Spiral",
"Fermat's Spiral",
"Folium",
"Folium of Descartes",
"Freeth's Nephroid",
"Frequency Curve",
"Hyperbola",
"Hyperbolic Spiral",
"Hypocycloid",
"Hypotrochoid",
"Involute of a Circle",
"Kampyle of Eudoxus",
"Kappa Curve",
"Lame Curves",
"Lemniscate of Bernoulli",
"Limacon of Pascal",
"Lissajous Curves",
"Lituus",
"Neile's SemiCubical Parabola",
"Nephroid",
"Parabola",
"PearShaped Quartic",
"Plateau Curves",
"Pursuit Curve",
"Quadratrix of Hippias",
"Rhodonea Curves",
"Right Strophoid",
"Serpentine",
"Sinusoidal Spirals",
"Spiral of Archimedes",
"Talbot's Curve",
"Tractrix",
"Tricuspoid",
"Trident of Newton",
"Trifolium",
"Trisectrix of Maclaurin",
"Tschirnhaus' Cubic",
"Watt's Curve",
"Witch of Agnesi"
});

curvesNameList.setPreferredVisibleRows(10);

newOuijiButton = new BButton("Select!");

newOuijiButton.addEventLink(CommandEvent.class, new Runnable() {

	void run()

	{  
	
	private int curveNdx = curveSelection();
		
    private String detectedCurveTyp = curveTypeDetection();

	private String selectedCurveName = getSelectedCurveName();
	
    private int gotCurvePonentDialogType = getCurvePonentDialogType(detectedCurveTyp);
	
	makeCurvePonentDialog(selectedCurveName, curveNdx, detectedCurveTyp, gotCurvePonentDialogType);
	
	}
	
    }, "run");
	
	
static int curveSelection(){

       private int curveSelected = curvesNameList.getSelectedIndex();
							      
       return curveSelected;
                            }
											
											
static String getSelectedCurveName(){

       private String selectedCurveName = curvesNameList.getSelectedValue();
	   
	   return selectedCurveName;
	                            }
											 
																						 
static String curveTypeDetection(){

	   private String curveName = curvesNameList.getSelectedValue();
	   
	   private int curveNdx = curvesNameList.getSelectedIndex();
       
	   private String detectEdCurveType;

       // I will make the following 114 lines a separate method when I get things finished (finishing on 'line 239')....
	   
	   // What follows is a draft way of detecting the Curve/Trajectory 'type', I've tried 'futureproofing' the technique..
	   
	   // ..by providing for the addition of new Curve/Trajectories; hence the 'process of verification':
	   
	   private int cNLIC = curvesNameList.getItemCount();
	   
	   if (cNLIC != 54){
	                    
	   print("The Curve/Trajectory Script requires re-working (A); mail: kevinzwolf via users.sourceforge.net"); 
	   				
	   // ...here if we find that a new Curve/Trajectory was added ('half' added) then we request contact & close up shop...				
						
						return;
						} 
	                    else{
						
	   // ...else we continue (yes, I am sure as I write this that this is a job for try, catch & finally..)...	
	   
	   private String[] curvesNameArray = new String[] {  "Astroid",
                                                          "Cardioid",
                                                          "Catenary",
						                                  "Cayley's Sextic",
						                                  "Cissoid of Diocles",
                                                          "Cochleoid",
                                                          "Conchoid",
                                                          "Conchoid of de Sluze",
                                                          "Cycloid",
                                                          "Devil's Curve",
                                                          "Double Folium",
                                                          "Eight Curve",
                                                          "Ellipse",
                                                          "Epicycloid",
                                                          "Epitrochoid",
                                                          "Equiangular Spiral",
                                                          "Fermat's Spiral",
                                                          "Folium",
                                                          "Folium of Descartes",
                                                          "Freeth's Nephroid",
                                                          "Frequency Curve",
                                                          "Hyperbola",
                                                          "Hyperbolic Spiral",
                                                          "Hypocycloid",
                                                          "Hypotrochoid",
                                                          "Involute of a Circle",
                                                          "Kampyle of Eudoxus",
                                                          "Kappa Curve",
                                                          "Lame Curves",
                                                          "Lemniscate of Bernoulli",
                                                          "Limacon of Pascal",
                                                          "Lissajous Curves",
                                                          "Lituus",
                                                          "Neile's SemiCubical Parabola",
                                                          "Nephroid",
                                                          "Parabola",
                                                          "PearShaped Quartic",
                                                          "Plateau Curves",
                                                          "Pursuit Curve",
                                                          "Quadratrix of Hippias",
                                                          "Rhodonea Curves",
                                                          "Right Strophoid",
                                                          "Serpentine",
                                                          "Sinusoidal Spirals",
                                                          "Spiral of Archimedes",
                                                          "Talbot's Curve",
                                                          "Tractrix",
                                                          "Tricuspoid",
                                                          "Trident of Newton",
                                                          "Trifolium",
                                                          "Trisectrix of Maclaurin",
                                                          "Tschirnhaus' Cubic",
                                                          "Watt's Curve",
                                                          "Witch of Agnesi"
						                                  };
						  
						  
						  private String curveNameCheckEd = curvesNameArray[curveNdx];
						  
						  private boolean curveNameOKd = curveName.equals(curveNameCheckEd);
						  
						  // ..here we are providing for any juggling 'round of the Curve/Trajectory List...
						  
						  if (curveNameOKd == true){

                          // ..if we find all is OK-ed, then we proceed...(safely, we hope...)...
 
                          private String[] curveTypesArray = new String[] { "a", "a", "a", "a", "a", "a",
                                                   						    "ba", "ka", "ha", "a", "a", "a", 
																		    "ba", "ba", "cba", "ba", "a", 
																		    "ba", "a", "a", "F", "ba", "a", 
																		    "ba", "cba", "a", "ba", "a", 
																		    "ba", "a", "ba", "ncba", "a", 
																		    "a", "a", "cba", "ba", "nma", "c", 
																		    "a", "ka", "a", "ba", "pa", "a", 
																		    "fba", "T", "a", "fedc", "a", "a", 
																		    "a", "cba", "a"
									                                        };
						 
						 detectEdCurveType = curveTypesArray[curveNdx];
                         
						                            }else{
													
	   print("The Curve/Trajectory Script requires re-working (J); mail: kevinzwolf via users.sourceforge.net"); 	 
														  
														   return;
						                                  }				
														  
       // ...same 'chimpanzee logic' works here... stage by stage verification....			
       
                             }
							 		
	   // ...closing that big 'else' that began after we established that the list the user sees is the 'right' length..
	   
	   // ...I will finish that method here.. (began 'line 125')...
	   
	   return detectEdCurveType; 

	   }
	   
	   	   
static int getCurvePonentDialogType(dlivrdCurveType){
       
       private String soughtCurvePonentNdy = dlivrdCurveType;
	  
       private int ndyLength = soughtCurvePonentNdy.length();
	   
	   return ndyLength;                     	     
	   
	   }	   

	   
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	   
	   	   
// Mathematics 'lowerCaseMethods' Section


 static double sinh(double tAngle) {

  return ((Math.exp(tAngle) - Math.exp(-tAngle))/2);

 }

 static double cosh(double tAngle) {

  return ((Math.exp(tAngle) + Math.exp(-tAngle))/2);

 }

 static double tanh(double tAngle) {

  return (sinh(tAngle)/cosh(tAngle));

 }

 static double sec(double tAngle) {

  return 1/Math.cos(tAngle);

 }

 static double cosec(double tAngle) {

  return 1/Math.sin(tAngle);

 }

 static double cotan(double tAngle) {

  return 1/Math.tan(tAngle);

 }

	   
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	 	   
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



 // ..a 'sign' Method..

 static double sign(double dlivrdValue) {

  if (dlivrdValue > 0) { return 1;} else {if (dlivrdValue < 0) { return -1;} else { return 0;}}
  
                                         }  
 // ..the 'traces' Methods                    

  public static double[] astroidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {
  
  private int itrns = dlivrdItrns;
  
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.pow(a*Math.cos(tAngle), 3.0);

    myY = a*Math.pow(a*Math.sin(tAngle), 3.0);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] cardioidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
  
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
    
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private double myX = 0;
  
  private double myY = 0;
 
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*(1 + Math.cos(tAngle));

    myY = a*Math.sin(tAngle)*(1 + Math.cos(tAngle)); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] catenaryM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private double myX = 0;
  
  private double myY = 0;
 
   for (int i=0; i<itrns; i++) {

    myX = tAngle - 5;

    myY = a*cosh((tAngle - 5)/a);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] cayleysSexticM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
     
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*4*Math.pow(Math.cos(tAngle/3), 3);

    myY = a*Math.sin(tAngle)*4*Math.pow(Math.cos(tAngle/3), 3); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] cissoidOfDioclesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = 2*a*Math.cos(tAngle)*Math.tan(tAngle)*Math.sin(tAngle);

    myY = 2*a*Math.sin(tAngle)*Math.tan(tAngle)*Math.sin(tAngle); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] cochleoidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*Math.sin(tAngle)/tAngle;

    myY = a*Math.pow(Math.sin(tAngle), 2)/tAngle; 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] conchoidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.cos(tAngle)*(a + b*sec(tAngle));

    myY = Math.sin(tAngle)*(a + b*sec(tAngle)); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] conchoidOfDeSluzeM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdK) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float k = dlivrdK;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.cos(tAngle)*(-a/Math.cos(tAngle) + (k*k/a)*Math.cos(tAngle));

    myY = Math.sin(tAngle)*(-a/Math.cos(tAngle) + (k*k/a)*Math.cos(tAngle)); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] cycloidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdH) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private double h = dlivrdH;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*(tAngle - 22) - h*Math.sin(tAngle - 22);

    myY = a - h*Math.cos(tAngle - 22);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] devilsCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

myX = a*Math.cos(tAngle)*Math.sqrt((25 - 24*Math.pow(Math.tan(tAngle), 2))/(1 - Math.pow(Math.tan(tAngle), 2)));

myY = a*Math.sin(tAngle)*Math.sqrt((25 - 24*Math.pow(Math.tan(tAngle), 2))/(1 - Math.pow(Math.tan(tAngle), 2))); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
     
  
  public static double[] doubleFoliumM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = 4*a*Math.cos(tAngle)*Math.cos(tAngle)*Math.pow(Math.sin(tAngle), 2);

    myY = 4*a*Math.sin(tAngle)*Math.cos(tAngle)*Math.pow(Math.sin(tAngle), 2); 

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] eightCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;    
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*Math.sqrt(Math.cos(2*tAngle))*Math.pow(sec(tAngle), 2);

    myY = a*Math.sin(tAngle)*Math.sqrt(Math.cos(2*tAngle))*Math.pow(sec(tAngle), 2);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] ellipseM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = this.a*Math.cos(tAngle);

    myY = this.b*Math.sin(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    

  public static double[] epicycloidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = (a + b)*Math.cos(tAngle) - b*Math.cos((a/b + 1)*tAngle);

    myY = (a + b)*Math.sin(tAngle) - b*Math.sin((a/b + 1)*tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] epitrochoidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB, dlivrdC) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
  
  private float c = dlivrdC;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = (a + b)*Math.cos(tAngle) - c*Math.cos((a/b + 1)*tAngle);

    myY = (a + b)*Math.sin(tAngle) - c*Math.sin((a/b + 1)*tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] equiangularSpiralM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(4*(tAngle - Math.PI))*Math.exp(cotan(b)*4*(tAngle - Math.PI));

    myY = a*Math.sin(4*(tAngle - Math.PI))*Math.exp(cotan(b)*4*(tAngle - Math.PI));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] fermatsSpiralM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle - 24)*Math.sqrt(Math.abs(tAngle - 24))*sign(tAngle - 24);

    myY = a*Math.sin(tAngle - 24)*Math.sqrt(Math.abs(tAngle - 24));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] foliumM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.cos(tAngle)*(-b*Math.cos(tAngle) + 4*a*Math.cos(tAngle)*Math.pow(Math.sin(tAngle), 2));

    myY = Math.sin(tAngle)*(-b*Math.cos(tAngle) + 4*a*Math.cos(tAngle)*Math.pow(Math.sin(tAngle), 2));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] foliumOfDescartesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = 3*a*(tAngle)/(1 + Math.pow(tAngle, 3.0));

    myY = 3*a*Math.pow(tAngle, 2.0)/(1 + Math.pow(tAngle, 3.0));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] freethsNephroidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*(1 + 2*Math.sin(tAngle/2));

    myY = a*Math.sin(tAngle)*(1 + 2*Math.sin(tAngle/2));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] frequencyCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdDummyVariable) {
  
  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private int dv = dlivrdDummyVariable;
  
  private double myX = 0;
  
  private double myY = 0;
     
   for (int i=0; i<itrns; i++) {

    myX = (tAngle - 4);

    myY = Math.sqrt(2)*Math.exp(-Math.pow(tAngle - 4, 2.0)/2);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] hyperbolaM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*sec(tAngle);

    myY = b*Math.tan(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] hyperbolicSpiralM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;  
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)/tAngle;

    myY = a*Math.sin(tAngle)/tAngle;

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] hypocycloidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = (a - b)*Math.cos(tAngle) + b*Math.cos((a/b - 1)*tAngle);

    myY = (a - b)*Math.sin(tAngle) + b*Math.sin((a/b - 1)*tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] hypotrochoidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB, dlivrdC) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
  
  private float c = dlivrdC;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = (a - b)*Math.cos(tAngle) + c*Math.cos((a/b - 1)*tAngle);

    myY = (a - b)*Math.sin(tAngle) + c*Math.sin((a/b - 1)*tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] envoluteOfACircleM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*(Math.cos(tAngle) + tAngle*Math.sin(tAngle));

    myY = a*(Math.sin(tAngle) - tAngle*Math.cos(tAngle));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] kampyleOfEudoxusM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = b*b/(a*Math.cos(tAngle));

    myY = b*b*Math.sin(tAngle)/(a*Math.pow(Math.cos(tAngle), 2));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] kappaCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*cotan(tAngle);

    myY = a*Math.cos(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] lameHaCurvesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   
  
  private float b = dlivrdB;
  
  private double oneQuarter = 1/4;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

//    myX = a*Math.pow(Math.cos(tAngle - 4)*Math.cos(tAngle - 4), oneThird)*sign(Math.cos(tAngle - 4));

//    myY = b*Math.pow(Math.sin(tAngle - 4)*Math.sin(tAngle - 4), oneThird)*sign(Math.sin(tAngle - 4));

	myX = a*Math.pow(Math.cos(tAngle)*Math.cos(tAngle), oneQuarter)*sign(Math.cos(tAngle));

    myY = b*Math.pow(Math.sin(tAngle)*Math.sin(tAngle), oneQuarter)*sign(Math.sin(tAngle));

	
	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] lemniscateOfBernoulliM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*Math.sqrt(Math.cos(2*tAngle));

    myY = a*Math.sin(tAngle)*Math.sqrt(Math.cos(2*tAngle));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] limaconOfPascalM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.cos(tAngle)*(b + 2*a*Math.cos(tAngle));

    myY = Math.sin(tAngle)*(b + 2*a*Math.cos(tAngle));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[]
                lissajousCurvesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB, dlivrdC, dlivrdN) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;

  private int c = dlivrdC;
  
  private float n = dlivrdN;
   
  private double myX = 0;
  
  private double myY = 0;
  
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.sin(n*tAngle + c);

    myY = b*Math.sin(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                        return myXYArray; }
    
  
  public static double[] lituusM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle - 28)/Math.sqrt(Math.abs(tAngle - 28))*sign(tAngle - 28);

    myY = a*Math.sin(tAngle - 28)/Math.sqrt(Math.abs(tAngle - 28));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] neilesSemiCubicalParabolaM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = tAngle-30;

    myY = Math.pow(a*(tAngle - 30)*(tAngle - 30), 0.33333);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] nephroidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*(3*Math.cos(tAngle) - Math.cos(3*tAngle));

    myY = a*(3*Math.sin(tAngle) - Math.sin(3*tAngle));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] parabolaM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB, dlivrdC) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;
  
  private float c = dlivrdC;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = tAngle - 4;

    myY = a*(tAngle - 4)*(tAngle - 4) + b*(tAngle - 4) + c;

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] pearShapedQuarticM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.abs(tAngle - 3);

    myY = (1/b)*(tAngle - 3)*Math.sqrt(-Math.pow((tAngle - 3), 2)+a*Math.abs(tAngle - 3))/2;

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] plateauCurvesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdM, dlivrdN) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private double m = dlivrdM;
  
  private double n = dlivrdN;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*(Math.sin((m + n)*tAngle))/(Math.sin((m - n)*tAngle));

    myY = (2*a*Math.sin(m*tAngle)*Math.sin(n*tAngle))/(Math.sin((m - n)*tAngle));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] pursuitCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdC) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float c = dlivrdC;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = tAngle;

    myY = c*tAngle*tAngle - Math.log(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] quadratrixOfHippiasM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = tAngle - 8;

    myY = a*cotan(Math.PI*(tAngle - 8)/(2*a));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] rhodoneaCurvesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdK) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float k = dlivrdK;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*Math.sin(k*tAngle);

    myY = a*Math.sin(tAngle)*Math.sin(k*tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] rightStrophoidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(2*tAngle);

    myY = a*Math.cos(2*tAngle)*Math.tan(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] serpentineM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;
   
  private double myX = 0;
  
  private double myY = 0;
  
   if (a*b<0) { b = -b;}

   for (int i=0; i<itrns; i++) {

    myX = tAngle - 5;

    myY = a*a*(tAngle - 5)/((tAngle - 5)*(tAngle - 5) + a*b);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] sinusoidalSpiralsM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdP) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;   

  private double p = dlivrdP;
   
  private double myX = 0;
  
  private double myY = 0;
  
  private double recipP = 1/p; 
  
   for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*Math.pow(Math.cos(p*tAngle), recipP);

    myY = a*Math.sin(tAngle)*Math.pow(Math.cos(p*tAngle), recipP);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] spiralOfArchimedesM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*tAngle*Math.cos(tAngle);

    myY = a*tAngle*Math.sin(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] talbotsCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB, dlivrdF) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;
  
  private float f = dlivrdF;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = (a*a + f*f*Math.pow(Math.sin(tAngle),2))*Math.cos(tAngle)/a;

    myY = (1/b)*(a*a - 2*f*f + f*f*Math.pow(Math.sin(tAngle),2))*Math.sin(tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] tractrixM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdDummyVariable) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
   
  private int dv = dlivrdDummyVariable; 
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = 1/cosh(tAngle - 5);

    myY = tAngle - 5 - tanh(tAngle - 5);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] tricuspoidM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = a*(2*Math.cos(tAngle) + Math.cos(2*tAngle));

    myY = a*(2*Math.sin(tAngle) - Math.sin(2*tAngle));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] nsTridentM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdC, dlivrdD, dlivrdE, dlivrdF) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float c = dlivrdC;
  
  private float d = dlivrdD; // note this & above...
  
  private float e = dlivrdE;
  
  private float f = dlivrdF;
  
  private double myX = 0;
  
  private double myY = 0;
 
   for (int i=0; i<itrns; i++) {

    myX = tAngle-4;

    myY = c*(tAngle - 4)*(tAngle - 4) + d*(tAngle - 4) + e + f/(tAngle - 4);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] trifoliumM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
  for (int i=0; i<itrns; i++) {

    myX = a*Math.cos(tAngle)*(-Math.cos(tAngle) + 4*Math.cos(tAngle)*Math.pow(Math.sin(tAngle), 2));

    myY = a*Math.sin(tAngle)*(-Math.cos(tAngle) + 4*Math.cos(tAngle)*Math.pow(Math.sin(tAngle), 2));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] trisectrixOfMacLaurinM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = 2*a*Math.cos(tAngle)*Math.sin(3*tAngle)/Math.sin(2*tAngle);

    myY = 2*a*Math.sin(tAngle)*Math.sin(3*tAngle)/Math.sin(2*tAngle);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] tschirnhausCubicM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.abs(tAngle - 2);

    myY = (tAngle - 2)*Math.sqrt((Math.abs(tAngle - 2) - 2*a + a*a/Math.abs(tAngle - 2))/(3*a));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
  
  public static double[] wattsCurveM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA, dlivrdB, dlivrdC) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private float b = dlivrdB;
  
  private float c = dlivrdC;
   
  private double myX = 0;
  
  private double myY = 0;
  
   for (int i=0; i<itrns; i++) {

    myX = Math.cos(tAngle)*Math.sqrt(b*b - Math.pow(a*Math.sin(tAngle)
	                                                                +
	(Math.abs(tAngle - 2*Math.PI)/(tAngle - 2*Math.PI))*Math.sqrt(c*c - a*a*Math.pow(Math.cos(tAngle), 2)), 2));

    myY = Math.sin(tAngle)*Math.sqrt(b*b - Math.pow(a*Math.sin(tAngle)
	                                                                +
	(Math.abs(tAngle - 2*Math.PI)/(tAngle - 2*Math.PI))*Math.sqrt(c*c - a*a*Math.pow(Math.cos(tAngle), 2)), 2));

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
                                 }                                                      return myXYArray; }
    
    
  public static double[] witchOfAgnesiM(dlivrdItrns, dlivrdPrec, dlivrdAngle, dlivrdA) {

  private int itrns = dlivrdItrns;
    
  private int ndx = itrns*2;
  
  private double[] myXYArray = new double[ndx];
  
  private float deltaTA = dlivrdPrec;
  
  private double tAngle = dlivrdAngle;
  
  private float a = dlivrdA;
  
  private double myX = 0;
  
  private double myY = 0;
 
   for (int i=0; i<itrns; i++) {

    myX = a*(tAngle - 5);

    myY = a/((tAngle - 5)*(tAngle - 5) + 1);

	myXYArray[ndx - 1] = myY;
	
	ndx--;
	
	myXYArray[ndx - 1] = myX;
	
	ndx--;
	
	tAngle = tAngle + deltaTA;
	
   }                                                                                    return myXYArray; }
   
   
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
     // ...end    Mathematics                                 Section
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //         of                    'lowerCaseMethods'             .....
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	 	   
	   
// makeCurvePonentDialogCurveType Section....

static void makeCurvePonentDialog(dlivrdName, dlivrdCurveNdx, dlivrdCurveType, gotCTDType){
		
		private String ouiJiName = dlivrdName;
		
		private int ouiJiCTNdx = dlivrdCurveNdx;
		
		private String ouiJiCurT = dlivrdCurveType;
		
		private int ouiJiCTDNdx = gotCTDType;
		
		// Seven 'omnipresent' ValueFields:
		
		precisionValueField = new ValueField(0.1, ValueField.NONE);
		
		iterationsValueField = new ValueField(100, ValueField.NONE);
		
		theAngleValueField = new ValueField(0, ValueField.NONE);
		
		theFirstXValueField = new ValueField(0, ValueField.NONE);
		
		theFirstYValueField = new ValueField(0, ValueField.NONE);
		
		theFirstZValueField = new ValueField(0, ValueField.NONE);
		
		theDeltaZValueField = new ValueField(0, ValueField.NONE);
		
		// The 'options' ValueFields:
		
		aParameterValueField = new ValueField(1.0, ValueField.NONE);
		
		bParameterValueField = new ValueField(0.5, ValueField.NONE);
		
		cParameterValueField = new ValueField(3.0, ValueField.NONE);
		
		dParameterValueField = new ValueField(-4.0, ValueField.NONE);
		
		eParameterValueField = new ValueField(1.0, ValueField.NONE);
		
		fParameterValueField = new ValueField(-1.0, ValueField.NONE);
		
		hParameterValueField = new ValueField(2.0, ValueField.NONE);
		
		kParameterValueField = new ValueField(2.0, ValueField.NONE);
		
		mParameterValueField = new ValueField(5.0, ValueField.NONE);
		
		nParameterValueField = new ValueField(3.0, ValueField.NONE);
		
		pParameterValueField = new ValueField(0.571429, ValueField.NONE);
		
		// ...end of 'options' ValueFields
		
		// ...ouiJi 'blank' ValueFields & Names
		
		valueFieldOne = new ValueField(0, ValueField.NONE);
		
		valueFieldTwo = new ValueField(0, ValueField.NONE);
		
		valueFieldThr = new ValueField(0, ValueField.NONE);
		
		valueFieldFou = new ValueField(0, ValueField.NONE);
				
		private String vFOName;
		
		private String vFOff = "";
		
		// ...will switch off vFO for 'frequency curve' & 'tractrix'...
		
		private String vFTName;
		
		private String vF3Name;
		
		private String vF4Name;
		
	    // ...end of ouiJi 'blank' ValueFields & Names
		
		// ...the (literally) revolutionary 'flipButtons' set-up section
		
		flipButtons = new RadioButtonGroup();
		
        flipXYZ = new BRadioButton("XYZ", true, flipButtons);
		flipXZY = new BRadioButton("XZY", false, flipButtons);
		flipYXZ = new BRadioButton("YXZ", false, flipButtons);		
		flipYZX = new BRadioButton("YZX", false, flipButtons);        
		flipZXY = new BRadioButton("ZXY", false, flipButtons);		
		flipZYX = new BRadioButton("ZYX", false, flipButtons);		

		flipGridCon = new GridContainer(2, 3);
		
flipGridCon.setDefaultLayout(new LayoutInfo(LayoutInfo.WEST, LayoutInfo.NONE, new Insets(2, 2, 2, 2), null));														
        flipGridCon.add(flipXYZ, 0, 0);
		flipGridCon.add(flipXZY, 0, 1);
		flipGridCon.add(flipYXZ, 0, 2);
		flipGridCon.add(flipYZX, 1, 0);
		flipGridCon.add(flipZXY, 1, 1);
		flipGridCon.add(flipZYX, 1, 2);
		
		// ...end of the (literally) revolutionary 'flipButtons' set-up section
		
		ouiTBu = new BButton("'trace' this!");
		
		// ...either this is an 'ugly' way of doing things or my vanity's gone crazy... must actually study an algorithm one day soon...
		
		if (ouiJiCTDNdx == 1){
		
		if(ouiJiCurT.equals("a")){valueFieldOne = aParameterValueField; vFOName = "a";}
		else if(ouiJiCurT.equals("c")){valueFieldOne = cParameterValueField; vFOName = "c";}
		else if(ouiJiCurT.equals("F")){vFOName = null; vFOff = "off";} // ...these        don't         'constants'.....
		else if(ouiJiCurT.equals("T")){vFOName = null; vFOff = "off";} //            two           jave
		
		                      } else if (ouiJiCTDNdx == 2){
							         
									 if(ouiJiCurT.equals("ba")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = bParameterValueField; vFTName = "b";
									                           } else
									 if(ouiJiCurT.equals("ha")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = hParameterValueField; vFTName = "h";
									                           } else
									 if(ouiJiCurT.equals("ka")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = kParameterValueField; vFTName = "k";
									                           } else
									 if(ouiJiCurT.equals("pa")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = pParameterValueField; vFTName = "p";
									                           }
        									                      
														   } else if (ouiJiCTDNdx == 3){
									 if(ouiJiCurT.equals("cba")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = bParameterValueField; vFTName = "b";
									 valueFieldThr = cParameterValueField; vF3Name = "c";
									                           } else
									 if(ouiJiCurT.equals("fba")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = bParameterValueField; vFTName = "b";
									 valueFieldThr = fParameterValueField; vF3Name = "f";
									                           } else
									 if(ouiJiCurT.equals("fed")){
									 valueFieldOne = dParameterValueField; vFOName = "d";
									 valueFieldTwo = eParameterValueField; vFTName = "e";
									 valueFieldThr = fParameterValueField; vF3Name = "f";
									                           } else
									 if(ouiJiCurT.equals("nba")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = bParameterValueField; vFTName = "b";
									 valueFieldThr = nParameterValueField; vF3Name = "n";
									                           } else
									 if(ouiJiCurT.equals("nma")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = mParameterValueField; vFTName = "m";
									 valueFieldThr = nParameterValueField; vF3Name = "n";
									                           }															   
															   } else if (ouiJiCTDNdx == 4){
                                     if(ouiJiCurT.equals("ncba")){
									 valueFieldOne = aParameterValueField; vFOName = "a";
									 valueFieldTwo = bParameterValueField; vFTName = "b";
									 valueFieldThr = cParameterValueField; vF3Name = "c";
									 valueFieldFou = nParameterValueField; vF4Name = "n";
									                             }else
									 if(ouiJiCurT.equals("fedc")){
									 valueFieldOne = cParameterValueField; vFOName = "c";
									 valueFieldTwo = dParameterValueField; vFTName = "d";
									 valueFieldThr = eParameterValueField; vF3Name = "e";
									 valueFieldFou = fParameterValueField; vF4Name = "f";
									                              }}
									 
	
    // ...give the 'notorious' ouiTBu something t' do...
	
    ouiTBu.addEventLink(CommandEvent.class, new Runnable() {

	void run()

	{  
	
	pVF = precisionValueField.getValue();
	
	iVF = iterationsValueField.getValue();
	
	tAVF = theAngleValueField.getValue();
	
	vFO = valueFieldOne.getValue();
	
	if(ouiJiCTDNdx >= 2){vFT = valueFieldTwo.getValue();}
	
	if(ouiJiCTDNdx >= 3){vF3 = valueFieldThr.getValue();}
	
	if(ouiJiCTDNdx == 4){vF4 = valueFieldFou.getValue();}
	
	fXVF = theFirstXValueField.getValue();
	
	fYVF = theFirstYValueField.getValue();
	
	fZVF = theFirstZValueField.getValue();
	
	dZVF = theDeltaZValueField.getValue();
	
	doubleIVF = iVF*2;
	
	double[] reTurnEdArray = new double[doubleIVF];
	
	// ...now this must become reTurnEdArray = blahMethod(ouiTCTNdx, parameters....); if(ouiJiCTDNdx == banana){blah.. & cetera...

	switch(ouiJiCTNdx){
	
    case  0: reTurnEdArray = astroidM(iVF, pVF, tAVF, vFO);                             break;
    case  1: reTurnEdArray = cardioidM(iVF, pVF, tAVF, vFO);                            break;
    case  2: reTurnEdArray = catenaryM(iVF, pVF, tAVF, vFO);                            break;
    case  3: reTurnEdArray = cayleysSexticM(iVF, pVF, tAVF, vFO);                       break;
    case  4: reTurnEdArray = cissoidOfDioclesM(iVF, pVF, tAVF, vFO);                    break;
    case  5: reTurnEdArray = cochleoidM(iVF, pVF, tAVF, vFO);                           break;
    case  6: reTurnEdArray = conchoidM(iVF, pVF, tAVF, vFO, vFT);                       break;
    case  7: reTurnEdArray = conchoidOfDeSluzeM(iVF, pVF, tAVF, vFO, vFT);              break;
    case  8: reTurnEdArray = cycloidM(iVF, pVF, tAVF, vFO, vFT);                        break;
    case  9: reTurnEdArray = devilsCurveM(iVF, pVF, tAVF, vFO);                         break;
    case 10: reTurnEdArray = doubleFoliumM(iVF, pVF, tAVF, vFO);                        break;
    case 11: reTurnEdArray = eightCurveM(iVF, pVF, tAVF, vFO);                          break;
    case 12: reTurnEdArray = ellipseM(iVF, pVF, tAVF, vFO, vFT);                        break;
    case 13: reTurnEdArray = epicycloidM(iVF, pVF, tAVF, vFO, vFT);                     break;
    case 14: reTurnEdArray = epitrochoidM(iVF, pVF, tAVF, vFO, vFT, vF3);               break;
    case 15: reTurnEdArray = equiangularSpiralM(iVF, pVF, tAVF, vFO, vFT);              break;
    case 16: reTurnEdArray = fermatsSpiralM(iVF, pVF, tAVF, vFO);                       break;
    case 17: reTurnEdArray = foliumM(iVF, pVF, tAVF, vFO, vFT);                         break;
    case 18: reTurnEdArray = foliumOfDescartesM(iVF, pVF, tAVF, vFO);                   break;
    case 19: reTurnEdArray = freethsNephroidM(iVF, pVF, tAVF, vFO);                     break;
    case 20: reTurnEdArray = frequencyCurveM(iVF, pVF, tAVF, vFO);                      break; //fDummyVar
    case 21: reTurnEdArray = hyperbolaM(iVF, pVF, tAVF, vFO, vFT);                      break;
    case 22: reTurnEdArray = hyperbolicSpiralM(iVF, pVF, tAVF, vFO);                    break;
    case 23: reTurnEdArray = hypocycloidM(iVF, pVF, tAVF, vFO, vFT);                    break;
    case 24: reTurnEdArray = hypotrochoidM(iVF, pVF, tAVF, vFO, vFT, vF3);              break;
    case 25: reTurnEdArray = envoluteOfACircleM(iVF, pVF, tAVF, vFO);                   break;
    case 26: reTurnEdArray = kampyleOfEudoxusM(iVF, pVF, tAVF, vFO, vFT);               break;
    case 27: reTurnEdArray = kappaCurveM(iVF, pVF, tAVF, vFO);                          break;
    case 28: reTurnEdArray = lameHaCurvesM(iVF, pVF, tAVF, vFO, vFT);                   break;
    case 29: reTurnEdArray = lemniscateOfBernoulliM(iVF, pVF, tAVF, vFO);               break;
    case 30: reTurnEdArray = limaconOfPascalM(iVF, pVF, tAVF, vFO, vFT);                break;
    case 31: reTurnEdArray = lissajousCurvesM(iVF, pVF, tAVF, vFO, vFT, vF3, vF4);      break; 
    case 32: reTurnEdArray = lituusM(iVF, pVF, tAVF, vFO);                              break;
    case 33: reTurnEdArray = neilesSemiCubicalParabolaM(iVF, pVF, tAVF, vFO);           break;
    case 34: reTurnEdArray = nephroidM(iVF, pVF, tAVF, vFO);                            break;
    case 35: reTurnEdArray = parabolaM(iVF, pVF, tAVF, vFO, vFT, vF3);                  break;
    case 36: reTurnEdArray = pearShapedQuarticM(iVF, pVF, tAVF, vFO, vFT);              break;
    case 37: reTurnEdArray = plateauCurvesM(iVF, pVF, tAVF, vFO, vFT, vF3);             break; 
    case 38: reTurnEdArray = pursuitCurveM(iVF, pVF, tAVF, vFO);                        break;
    case 39: reTurnEdArray = quadratrixOfHippiasM(iVF, pVF, tAVF, vFO);                 break;
    case 40: reTurnEdArray = rhodoneaCurvesM(iVF, pVF, tAVF, vFO, vFT);                 break;
    case 41: reTurnEdArray = rightStrophoidM(iVF, pVF, tAVF, vFO);                      break;
    case 42: reTurnEdArray = serpentineM(iVF, pVF, tAVF, vFO, vFT);                     break;
    case 43: reTurnEdArray = sinusoidalSpiralsM(iVF, pVF, tAVF, vFO, vFT);              break;
    case 44: reTurnEdArray = spiralOfArchimedesM(iVF, pVF, tAVF, vFO);                  break;
    case 45: reTurnEdArray = talbotsCurveM(iVF, pVF, tAVF, vFO, vFT, vF3);              break;
    case 46: reTurnEdArray = tractrixM(iVF, pVF, tAVF, vFO);                            break; //tDummyVar
    case 47: reTurnEdArray = tricuspoidM(iVF, pVF, tAVF, vFO);                          break;
    case 48: reTurnEdArray = nsTridentM(iVF, pVF, tAVF, vFO, vFT, vF3, vF4);            break;
    case 49: reTurnEdArray = trifoliumM(iVF, pVF, tAVF, vFO);                           break;
    case 50: reTurnEdArray = trisectrixOfMacLaurinM(iVF, pVF, tAVF, vFO);               break;
    case 51: reTurnEdArray = tschirnhausCubicM(iVF, pVF, tAVF, vFO);                    break;
    case 52: reTurnEdArray = wattsCurveM(iVF, pVF, tAVF, vFO, vFT, vF3);                break;
    case 53: reTurnEdArray = witchOfAgnesiM(iVF, pVF, tAVF, vFO);                       break;
	
	// I've done the check here...& then set up vF4s as I said I'd do one day...
	
	                   }

	// ...ugly, ugly, ugly.... (the 'switch' ^ there)...
	
	print("Traced!: precision = " + pVF + ", number of points = " + iVF + "..& beginning angle = " + tAVF);
	
	print("\n");
	
	// ...& now for 'parenting/bundling' large number of new additions on the scene/window Objects Panel...
	

	parenTrace = new NullObject();
	
	parenTracEnformation = new ObjectInfo(parenTrace, new CoordinateSystem(), ouiJiName);

    window.addObject(parenTracEnformation, null);
	
	// ...& finished 'setting up'... see line 2770... //////////////////////////////////////////////////////////////////////////////
	
	int ijk = doubleIVF - 1;
	
	int iTh = 1;
	
	float xCoOrd = fXVF;
	
	float yCoOrd = fYVF;
	
	float zCoOrd = fZVF;
	
	float zVal = dZVF;
	
	// ...development of 'neuron' code:
	
	Vec3[] trArray = new Vec3[iVF]; 
	
	float[] smoothIness = new float[iVF];
	
	// ...see tracEdRawNeuron...
	
	while(ijk > 0){
	
    private double theX = reTurnEdArray[ijk - 1] - reTurnEdArray[doubleIVF - 2] + xCoOrd;
		
    private double theY = reTurnEdArray[ijk] - reTurnEdArray[doubleIVF - 1] + yCoOrd;
	
    private float theZ = zCoOrd;
		
	// give us some spheres (that'll show up on 3D)!
	
	sphere = new Sphere(0.1, 0.1, 0.1);
	
	// ...make the preceding an 'option'... not only size... but the 'simple'...
	
	flipXYZ.getState()? pos = new Vec3(theX, theY, theZ):
	flipXZY.getState()? pos = new Vec3(theX, theZ, theY):
	flipYXZ.getState()? pos = new Vec3(theY, theX, theZ):
	flipYZX.getState()? pos = new Vec3(theY, theZ, theX):
	flipZXY.getState()? pos = new Vec3(theZ, theX, theY):
	flipZYX.getState()? pos = new Vec3(theZ, theY, theX):
	print("..ooops, error(F)!; mail: kevinzwolf via users.sourceforge.net..");
	
	
	print(iTh + ": " + pos + "\n");
	
	ijk--;
	
	ijk--;
		
	zCoOrd = zCoOrd + zVal;	
		
	private String objectTitle = "the " + iTh + "th traceObject";
	
	iTh++;
	
	// ...line 2713, add some lines for ensuring the 'parenting/bundling' works...//////////////////////////////////////////////////
	
	objectCoOrdinateSystem = new CoordinateSystem(pos, 0, 0, 0);
	
	childTraceData = new ObjectInfo(sphere, objectCoOrdinateSystem, objectTitle);
	
	parenTracEnformation.addChild(childTraceData, parenTracEnformation.children.length);
	
	window.addObject(childTraceData, null);

	// ...& once we do a window.rebuildItemList() just after this loop, then we are done (& possibly dust(er)ed...)!
	
	trArray[iTh - 2] = pos; 
	
	smoothIness[iTh - 2] = 0;
	
	// ...preceding line adds another pos for use by tracEdRawNeuron
	
	}

	window.rebuildItemList();
	
    tracEdRawNeuron = new Curve(trArray, smoothIness, Mesh.APPROXIMATING, false);
	
	private String neuroName = ouiJiName + " / neuroneTrace";
	
	window.addObject(tracEdRawNeuron, new CoordinateSystem(), neuroName, null);
	
	}
	
	return;
	
    }, "run");
		


	
		if (ouiJiCTDNdx == 1){
		
		if (vFOff.equals("off")){
		
		ouiJi1 = new Widget[]{precisionValueField, iterationsValueField, theAngleValueField,
		                      theFirstXValueField, theFirstYValueField,
		                      theFirstZValueField, theDeltaZValueField, 
							  flipGridCon, ouiTBu};		
        
		// labels for those components...

		ouiSt1 = new String[]{"Precision", "Number of Points", "Beginning Angle",
		                                                       "begin X @",
															   "begin Y @",
															   "begin Z @",
															   "delta Z", "map XYZ >>>", null};}
		
		// 'F' (frequency curve) & 'T' (tractrix) are (actually) constant-less...
		
		else{
		
		ouiJi1 = new Widget[]{precisionValueField, iterationsValueField, theAngleValueField,
		                      valueFieldOne, 
							  theFirstXValueField, theFirstYValueField, theFirstZValueField,
							  theDeltaZValueField, flipGridCon, ouiTBu};
		
	    // labels for those components...

		ouiSt1 = new String[]{"Precision", "Number of Points", "Beginning Angle", ouiJiCurT, 
		                                                       "begin X @",
															   "begin Y @",
															   "begin Z @",
															   "delta Z", "map XYZ >>>", null};

             }
			 
		ouiCD1 = new ComponentsDialog(window, ouiJiName, ouiJi1, ouiSt1);
		
        	                  } else
		if (ouiJiCTDNdx == 2){
		
		ouiJi2 = new Widget[]{precisionValueField, iterationsValueField, theAngleValueField,
		                      valueFieldOne, valueFieldTwo, 
							  theFirstXValueField, theFirstYValueField, theFirstZValueField, 
							                       theDeltaZValueField, 
												   flipGridCon, ouiTBu};
		
	    // labels for those components...

		ouiSt2 = new String[]{"Precision", "Number of Points", "Beginning Angle", 
		                       vFOName, vFTName, 
							   "begin X @", "begin Y @", "begin Z @", "delta Z", "map XYZ >>>", null};
		
		ouiCD2 = new ComponentsDialog(window, ouiJiName, ouiJi2, ouiSt2);

        	                  } else
        if (ouiJiCTDNdx == 3){
		
		ouiJi3 = new Widget[]{precisionValueField, iterationsValueField, theAngleValueField,
		                      valueFieldOne, valueFieldTwo, valueFieldThr, 
							  theFirstXValueField, theFirstYValueField, theFirstZValueField, 
							                       theDeltaZValueField, 
												   flipGridCon, ouiTBu};
		
	    // labels for those components...

		ouiSt3 = new String[]{"Precision", "Number of Points", "Beginning Angle", 
		                       vFOName, vFTName, vF3Name, 
							   "begin X @", "begin Y @", "begin Z @", "delta Z", "map XYZ >>>", null};
		
		ouiCD3 = new ComponentsDialog(window, ouiJiName, ouiJi3, ouiSt3);

        	                  }else
        if (ouiJiCTDNdx == 4){
		
		ouiJi4 = new Widget[]{precisionValueField, iterationsValueField, theAngleValueField,
		                      valueFieldOne, valueFieldTwo, valueFieldThr, valueFieldFou,
                                                       theFirstXValueField,
                                                       theFirstYValueField,													      theFirstZValueField, theDeltaZValueField, 
													   flipGridCon, ouiTBu};
		
	    // labels for those components...

		ouiSt4 = new String[]{"Precision", "Number of Points", "Beginning Angle", 
		                       vFOName, vFTName, vF3Name, vF4Name, 
							   "begin X @", "begin Y @", "begin Z @", "delta Z", "map XYZ >>>", null};
		
		ouiCD4 = new ComponentsDialog(window, ouiJiName, ouiJi4, ouiSt4);

        	                  } // ...end 'if's...

							  return; // ...does I 'return' here? I s'pose so..... as Joe Byrne 'sez'; if not...
							  
									}

// end of makeCurvePonentDialogCurveTypeDialog Section....


									
// ...the opening ComponentDialog....

ouiJiCurve = new Widget[]{UIUtilities.createScrollingList(curvesNameList),
                          newOuijiButton};

ouiStCurve = new String[]{null, null};

private String tracesString = "TRajectory & CurvE Script";

ouiJiCurveDialog = new ComponentsDialog(window, tracesString, ouiJiCurve, ouiStCurve);


// ...wholly holy cow! ~ ....& it's done...