simplegraph4.frink

Download or view simplegraph4.frink in plain text format


// This is a simple but rather interesting program that graphs equations.
// You enter equations in terms of x and y, something like one of the
// following:
//
//  y = sin[x]
//
//  x^2 + y^2 = 81
//
//  y cos[x] = x sin[y]
//
// This version of the program can also graph INEQUALITIES, which have
// less-than or greater-than symbols instead of just equals.
//
// For example, try
//
// abs[y^2 + x^4 - 1] < cos[x]
// 
// This uses a recursive method to subdivide and test rectangles.

lasteq = ""

// If there are arguments to the program, graph them, otherwise prompt.
while func = (length[ARGS] > 0 ? ARGS@0 : input["Enter equation: ", lasteq])
{
   hasInequality = false
   certEq = undef
   lasteq = certFunc = func

   // If there's an inequality, let's make a test equation to see if we can
   // plot an entire rectangle using the "CERTAINLY" comparators.
   if func =~ %r/([<>]|!=)/
   {
      hasInequality = true
      certFunc =~ %s/<=/ CLE /g  // Replace <= with certainly less than or equals
      certFunc =~ %s/>=/ CGE /g  // Replace >= with certainly greater than or equals
      certFunc =~ %s/</ CLT /g   // Replace <  with certainly less than
      certFunc =~ %s/>/ CGT /g   // Replace >  with certainly greater than
      certFunc =~ %s/!=/ CNE /g   // Replace = with certainly not equals
      certFunc =~ %s/=/ CEQ /g   // Replace = with certainly equals
      certEq = parseToExpression[certFunc]
   }

   // These replacements turn normal comparator and equality tests into
   // "POSSIBLY EQUALS" tests.
   func =~ %s/<=/ PLE /g  // Replace <= with possibly less than or equals
   func =~ %s/>=/ PGE /g  // Replace >= with possibly greater than or equals
   func =~ %s/</ PLT /g   // Replace <  with possibly less than
   func =~ %s/>/ PGT /g   // Replace >  with possibly greater than
   func =~ %s/!=/ PNE /g   // Replace = with possibly not equals
   func =~ %s/=/ PEQ /g   // Replace = with possibly equals
   eq = parseToExpression[func]

   println[func]
   g = new graphics

   // Change the last number to vary the resolution.  This is the number
   // of doublings, so if the number is 10 we have 2^10=1024 doublings for
   // a resolution of 1024x1024.
   testRect[-10, 10, -10, 10, g, eq, certEq, 10]
   g.show[]
   g.write["graph2.png",1024,1024]

   if length[ARGS] > 0
      exit[]
}

// Recursive function to test an interval containing the specified bounds.
// If no possible solution exists, the recursion halts.  If a possible solution
// exists, this breaks it down into 4 sub-rectangles and tests each of them
// recursively.  level is the maximum number of levels to split, so the total
// resolution of the final graph will be 2^level.
testRect[x1, x2, y1, y2, g, eq, certEq, level] :=
{
   nextLevel = level - 1

   x = new interval[x1, x2]
   y = new interval[y1, y2]
   
   // Test the rectangle.  If it possibly contains solutions, recursively
   // subdivide.
   res = eval[eq]
   
   if res or res==undef
   {
      if (nextLevel >= 0)
      {
         if (certEq != undef)  // Do we have inequalities and a CERTAINLY test?
            if eval[certEq] == true
            {
               // If the entire rectangle is a solution, then fill the
               // rectangle and stop further recursion on this rectangle.
               g.fillRectSides[x1, -y1, x2, -y2]
               return
            }

         // Further subdivide the rectangle into 4 quadrants and recursively
         // test them all
         cx = (x1 + x2)/2
         cy = (y1 + y2)/2
         testRect[x1, cx, y1, cy, g, eq, certEq, nextLevel]
         testRect[cx, x2, y1, cy, g, eq, certEq, nextLevel]
         testRect[x1, cx, cy, y2, g, eq, certEq, nextLevel]
         testRect[cx, x2, cy, y2, g, eq, certEq, nextLevel]
      } else
           if (res)             // Valid point
              g.fillRectSides[x1, -y1, x2, -y2]
           else
           {
              // Error in evaluating point, plot in red.
              g.color[1,0,0]
              g.fillRectSides[x1, -y1, x2, -y2]
              g.color[0,0,0]
           }
   }
}


Download or view simplegraph4.frink in plain text format


This is a program written in the programming language Frink.
For more information, view the Frink Documentation or see More Sample Frink Programs.

Alan Eliasen was born 19944 days, 10 hours, 21 minutes ago.