for (int i=0; i<90; i++) {
    beginShape();
    for (int j=0; j<1000; j++) {
      // linear eq for increasing period:
      float period = .098*j + 30;
      // calculate wave height at current point:
      float sinHeight = -sin(((float)j/period)*PI);
      // draw point:
      vertex(j,40 + i*spacing + sinHeight*amplitude);
    }
    endShape();
  }

float radius = 50;
float period;
 
// separating each curve vertically by 5px
int lineSpacing = 5;
 
void setup() {
  size(800, 500);
  background(255);
  noFill();
}
 
void draw() {
  background(255);
 
  // need to draw 90 parallel lines
  for (int j = 0; j < (89*lineSpacing+1); j += lineSpacing){
    curve(j);
  }
}
 
void curve(int ly){
    period = 1;
    stroke(0);
    beginShape();
    for(int i=0; i<width; i++) {
        vertex(i, singraph((float)i/50)*radius + ly);
 
        period = period - 0.0009;
    }
    endShape();
}
 
float singraph(float sa) {
  //scale from -1 to 1
  sa = (sa - 0.5) * 1.0; 
  sa = sin(sa*2*PI*period)/2 + 0.5;
 
  return sa;
}

// Project 0 - Part A
// "Noll Sinusoids"
// Course:Special Topics in Interactive Art & Computational Design
// By: Mehrdad Ghods
// For project description please visit:
// "https://ems.andrew.cmu.edu/2010spring/projects/project-0/"
 
import processing.pdf.*;
 
// declare width and height of PDF page
int widthPDF = 800;
int heightPDF = 600;
// declare Sinusoid starting Y
float sinusoidY;
// declare margin
float margin = heightPDF / 20;
 
///////////////
// Main Methods
///////////////
 
// this method initialize renderer
// in this case pdf file renderer
void setup() {
  // create a 800X600 pixel one page PDF file
  //size(widthPDF, heightPDF);
  size(widthPDF, heightPDF, PDF, "NollSinusoids.pdf");
  // determine weight of strokes on 10
  strokeWeight(1.15);
  // draw anti-aliased edges
  smooth();
  // make background white
  background(255);
}
 
// this method draw using initialized renderer
void draw() {
  // draw 90 Sinusoids
  for(int i = 0; i < 90; i++){
    // determine sinusoid starting Y
    sinusoidY = margin + i * (heightPDF - (2 * margin)) / 90;
    // draw a Sinusoid
    drawNollSinusoid();
  }
  exit();
}
 
////////////////
// Helper Mthods
////////////////
 
// this method draw Noll a Sinusoid
void drawNollSinusoid(){
  // declare Sinusoids local X and Y
  float sinusoidLocalPX = 0;
  float sinusoidLocalX = 0;
  float sinusoidLocalPY = 0;
  float sinusoidLocalY = 0;
  // declare precision of drawing
  float precision = 1.0;
  // declare Sinusoid's properties
  // 1- amplitude
  float A = 5 * margin / 6;
  // 2- reverse of spatial frequency
  float k = 1.0 /(widthPDF / 120);
  // 3- phase
  float phase = 0;
 
  // draw Sinusoid by moving a point along page width, with height
  // determined by Sinusoid equation which is:
  // Y = A.Sin(k.X + phase), k divided by a linear function
  // each PI radians.
  while (sinusoidLocalX <= float(widthPDF)) {
    // to create a smoother view two points be calculated
    // and a line between them be drawn
    // increase X by one
    // calculate pervious X
    sinusoidLocalPX = sinusoidLocalX;
    // calculate X
    sinusoidLocalX += precision;
    // calculate Y - 1
    sinusoidLocalPY = sinusoidY - A * sin((PI / 180 * sinusoidLocalPX) / k);
    // calculate Y
    sinusoidLocalY = sinusoidY - A * sin((PI / 180 * sinusoidLocalX) / k);
    // draw a point od Sinusoid
    line(sinusoidLocalPX, sinusoidLocalPY, sinusoidLocalX, sinusoidLocalY);
    k += 0.0001 * (widthPDF / 120) * precision;
  }
}

graphics.lineStyle(1);
for (var why=50;why<590;why+=6){
	graphics.moveTo(0, why);
	for(var i=0;i<600;i++)
		graphics.lineTo(i, (why) - Math.sin(i/(10+(.03*i))) * 30);}

int linePlacement = 50;  //Y placement of first curve
int spacing = 5;         //Spacing between each curve
int amplitude = 30;      //Height of wave
float period = 30/PI;    //Initial period of wave
float curveData [];      //Container for Y data for single curve
 
void setup(){
  size(600,587);
  noLoop();  //Lets program run only once
  smooth();  //Smooths drawn elemens
 
  curveData = new float[width]; //Stores data for single curve
 
  background(255); //Set background to white
  stroke(0);  //Curve color is Black
  strokeWeight(.75);
 
  //Calculate Y data for a single curve
  for(int i=0; i< numberOfCurves; i++){
    for(int j=1; j < curveData.length; j++){
     line(j-1, curveData[j-1] + linePlacement + spacing*i, j, curveData[j] + linePlacement + spacing*i);  //Draw line part of curve
    }
  }
}

//1 Player Pong - Michael Hill
 
Player player1;
 
Ball ball;
 
boolean gameOver = true;
int highScore = 0;
int currentScore = 0;
 
PFont font;
 
//Holds keys that are currently pressed
ArrayList keysHeld;
 
void setup(){
  size(800, 400);
  frameRate(60);
  font = loadFont("VectorBattle-25.vlw"); //Loads font
  textFont(font); //Sets current Font
 
  keysHeld = new ArrayList();
  ball = new Ball();
 
  player1 = new Player(1);
 
}
 
void draw(){
  background(255);
 
  //Print Scores
  fill(60);
  text("High Score:" + highScore, width-textWidth("High Score:" + highScore)-10, 30);
  text("Current Score:" + currentScore, width-textWidth("Current Score:" + currentScore)-10, 60);
  fill(255);
 
 
  //Set High Score if necessary
  if (currentScore > highScore){
    highScore = currentScore;
  }
 
  processKeys();
  player1.drawPlayer();
 
  testBounce();
 
  if (gameOver == true){
    fill(0);
    text("Press Space To Begin", width/2-textWidth("Press Space To Begin")/2, 150);
 
    fill(255);
  }
  ball.drawBall(); 
}
 
void testBounce(){
   if (ball.posX = 0){
      if(ball.posY-30 >= player1.posY && ball.posY-30 <= player1.posY + 50){
        ball.posX = 41;
        ball.dX *= -1;
        ball.dX += 2;
        ball.dY += random(-2,2);
      }
      currentScore++;
   }
   else if (ball.posY = height - 10){
     ball.dY *=-1;
     currentScore++;
   }
   else if (ball.posX + 10 >= width){
     ball.dX *= -1;
     currentScore++; 
   }
   if (ball.posX < 20){
     gameOver = true;
   }
}
 
//Handles Key presses by pushing them to an array
void keyPressed() {
  int arrayIndex = 0;
  int totalKeys = keysHeld.size();
 
  if (totalKeys <= 0){
    KeyPress pressed = new KeyPress(keyCode);
    keysHeld.add(pressed);
  }
 
  else {
 
    for(int i = 0; i<totalKeys; i++){
      println( "Key " + i + " being analyzed");
      KeyPress pressed = (KeyPress) keysHeld.get(i);
      println ( String.valueOf(keyCode) + " was compared to " + String.valueOf(pressed.pressed));
      if (pressed.pressed == keyCode){
        break;
      }
      arrayIndex = i + 1;
    }
 
    //If the loop finished without breaking, add key to list
    if (totalKeys == arrayIndex){
      KeyPress pressed = new KeyPress(keyCode);
      keysHeld.add(pressed);
    }
  }
}
 
 
//Pops key from array when released
void keyReleased(){
  for(int i = 0; i < keysHeld.size(); i++){
    KeyPress pressed = (KeyPress) keysHeld.get(i);
    if (pressed.pressed == keyCode){
      keysHeld.remove(i);
    }
  }
}
 
 
//Checks all current keys that are held and runs their actions
void processKeys(){
  for (int i = 0; i < keysHeld.size(); i++){
    KeyPress currentKey = (KeyPress) keysHeld.get(i);
    if (currentKey.pressed == UP) {
      player1.moveUp();
    } 
    if (currentKey.pressed == DOWN) {
      player1.moveDown();
    } 
    if (currentKey.pressed == 32 && gameOver == true) {
      ball.resetBall();
      gameOver=false;
      currentScore = 0;
    }
  }
}

void drawNollSinusoids() {
  for (int i = 0; i < 90; i++){
    noFill();
    stroke(0);
    beginShape();
    period = (float) 0.125;
    for (int j = 20; j < 580; j++){
      x = j;
      y = 30 + (20 * sin( radians(j) / period ));
      curveVertex(x, y+(5*i));
      period += 0.0005;
    }
    endShape();
  }
  exit();
}

for (int y_cnt=0; y_cnt < 90; y_cnt++)
 
{
 
  float period = 0.10;
 
  beginShape();
 
  for (int x=0; x < width; x++)
 
  {
 
    float y = 20 * sin (radians(x) / period);
 
    vertex (x - 15, y + 100 + (y_cnt * 6));
 
    period += 0.00056;
 
  }
 
  endShape();
 
}

float x, y;
float amplitude = 30.0;
float offsetX, offsetY;
float period;
 
void setup() {
  size(640, 600);
  background(255);
}
 
void draw() {
  stroke(0);
  noFill();
  drawNollSinuoids();
 
  println("Finished.");
  exit();
}
 
void drawNollSinuoids() {
  for (int i = 0; i < 90; i++) {
    // Set the period (reciprocal of frequency) to that of the first curve.
    // offsetY pushes the sine curve into the view and then incrementally pushes it down farther
    // to create the optical illusion.
    period = 30 / PI;
    offsetY = 50 + i * 5.5;
    offsetX = PI;
 
    // Begin the shape for this line.
    beginShape();
 
    for (x = 0; x < width; x++) {
      // The first part of this equation sets the position of the line so that we get 90 iterations.
      // y = a sin(bx + c) + d where
      // y = a sin(x/b + c) + d
      // a = amplitude,
      // b = frequency,
      // c = x offset,
      // d = y offset
 
      // Create the curve equation.
      // We offset the X by PI to push it to the left one period for the desired effect. 
      y = sin(x / period + offsetX);
 
      // Reverse the x values so that we get the higher frequency waves first, and lower frequency waves gradually,
      // then create the vector point.
      vertex(x, amplitude * y + offsetY);  
 
      // Increment the period
      period += 0.038;
    }  
    // End the shape for this line.
    endShape();
  }
}

y=\frac{1}{45}\left( \sin \left( \frac{2\pi \cdot x}{x+1} \right)+\frac{a}{10} \right)

/*project-0 reproduce Michael Noll's computer art:
Ninety Parallel Sinusoids With Linearly Increasing Perio*/
float yoffset=40;
float amplitude=30;  //the 1/2 of y peak-to-peak difference
float period=30/PI;  //the initional x wavelength
float shift=PI;      //the amount that shift to left
 
void setup(){
  size(590,590);
  background(255);
  smooth();
  noFill();
  noLoop();
}
 
void draw(){
  stroke(0);
  for(int i=0;i<90;i++){   //reproduce the curve 90 times with different yposition
    beginShape();
       for(int x=0;x<=width;x++){
       float y = amplitude*sin(x/period+shift)+yoffset; // y=asin(bx+c)+d
       vertex(x,y);         //draw cruve
       period+=PI/100;      //linearly increase the period
     }
    endShape();
    period=30/PI;  //reset the period
    yoffset+=5.8;  //shift the yposition down
  }
}

import processing.pdf.*;
 
//Project 0 
//Solomon Bisker
 
//Some code adapted from Sine Wave example at processing.org
//by Daniel Shiffman (since a the fastest way to learn an API is to study
//someone else's code)
 
int xspacing = 1;   // Initial spacing difference (base value for dx)
int w;              // Width of entire wave
 
int yoffset = 5; //Spacing between horizontal waves, in pixels
 
float theta = 0.0;  // Start angle at 0
float amplitude = 75.0;  // Height of wave
float baseperiod = 100.0;  // How many pixels in a full cycle for first period
float dx;  // Intermediate value for incrementing X (recalculated each time)
float[] yvalues;  // Using an array to store height values for the wave
 
void setup() {
  size(800,800);
  noLoop();
  beginRecord(PDF, "nollknockoff.pdf");
  smooth();
  w = width;
  //Calculate initial dx (with period of 1)
  dx = (TWO_PI / baseperiod) * xspacing ;
  yvalues = new float[800];
}
 
void draw() {
  //Let's just calculate the wave once and draw it 90 times.
  //Seems faster.
 
  //First, calculate and store the wave values
  calcWave();
 
  //Now, we draw the wave 90 times.
  //i simply tells us which wave it is (triggering appropriate
  //horizontal offset in its rendering)
  for (int i=0; i < 90; i++){
      renderWave(i);
  }
  //Stop writing to PDF; finish saving PDF.
  endRecord();
}
 
 
void calcWave() {
 
  // For every x value, calculate a y value with sine function
  float x = theta;
 
  //We create the "increasing period" by calcuating the regular value of
  //a normal sine function, but just offsetting x each time a linear amount
  //and using interpolation between each point (curveVertex).
 
    for (int j = 0; j < yvalues.length; j++) 
    {
    //Store that calcuated value
    yvalues[j] = sin(x)*amplitude;
 
    dx = (TWO_PI / baseperiod) * xspacing / (float) (1+(float) j/100) ;
    x+=dx;
    }
 
}
 
 
void renderWave(int i) {
  // A simple way to draw the wave with an ellipse at each location
  //We draw the waves from page top, downward as i increases
 
  //For each x,y  pair in the function, draw a point, with y value
  //offset by i times some y offset constant...
 
  noFill();
  beginShape();
  for (int x = 0; x < yvalues.length; x++) {
    curveVertex(x*xspacing,i*yoffset+amplitude+yvalues[x]);
  }
  endShape();
 
}

float angle = 90.0;
float padding = 0.015;
float count=0.0;
int start=50;
 
for(int i=0; i<90; i++) {
  count=0.0;
  angle=90.0;
  beginShape();
  for (float x=5.0; x<=width; x+=1) {
    float y = start+(cos(angle)*40.0);
    x += count*padding;
    vertex(x, y);
    angle+=PI/35.0;
    count++;
  }
  endShape();
  start += 5;
}

float ballX;
float ballY;
float ballXv;
float ballYv;
 
void setup() {
  size(300,300);
  smooth();
  noStroke();
  reset();
}
 
void draw() {
  background(24,201,234);
  ballX +=ballXv;
  ballY += ballYv;
 
  ellipseMode(CENTER);
  ellipse(ballX, ballY, 10, 10);
 
  //paddle
  rectMode(CENTER);
  int px=290;
  int ph=30;
  int ppos= constrain(mouseY, 0 , height);
  rect(px, ppos, 5, ph);
 
  //test for boundaries
  if (ballX < 0) {
    ballXv*=-1;
  }
  if ((ballY  height)) {
    ballYv*=-1;
  }
  if (((ballX>285) && (ballYmouseY-(ph/2))) {
    ballXv*=-1;
  }
}
 
void mousePressed() {
  reset();
}
 
void reset() {
  ballX= 1;
  ballY= height/2;
  ballXv= random(2.5, 3.5);
  ballYv= random(-1, 1);
}