transaction script "trivial goal 
 {
 // This is a trivial example, in that the target and result are direct 
 // measures of the same parameter on a line. Thus, we could simply set the 
 // result to the target. However, this simplicity lets us explain the code 
 // structure more clearly.
 // 
 // The features we name "driver" and "trackLine" already exist in the 
 // model. We just access them here. The "trackLine" is the curve on which 
 // the parametric point "driver" lies.
 
 Point driver = FindFeature("pointOnLine");
 ICurve trackLine = driver.Curve;
 
 // We aim to find the result such that the driver parameter (T) is equal
 // to the target. Choose an arbitrary target value. Any value would work.
 
 double target = 0.6;
 
 // In this example, we assume that the driver's parameter is less than the target.
 // Generalizing this requires an additional test that would obscure the 
 // essential action of the Goal Seeker.
 
 driver.ByParameterAlongCurve(trackLine, 0.3);
 
 
 // Set the result to whatever the driver's parameter happens to be now.
 
 double result = driver.T;
 
 // "CurrentT" stores the current T value so that we can reverse the search
 // should it overshoot the target.
 
 double currentT;  
 
 // "Increment" is an (almost) arbitrary choice of the initial increment
 // for the search. It is almost arbitrary, because it must be chosen so that
 // a single increment does not completely skip a region of interest.  
 // In this case, the increment must be such it moves the result towards
 // the target.
 
 double increment = 0.2;
 
 // "incrementAdded" counts the number of times that the increment has been
 // added to currentT.
 
 int incrementAdded = 0;
 
 // " incrementSubdivided " counts the number of times that the increment has
 // been halved in the search.
 
 int incrementSubdivided =0;
 
 // "closeEnough" is the threshold for the search. Once the result is
 // closeEnough to the target, we stop.
 
 double closeEnough = 0.000001;
 
 // "giveUpWhen" is the threshold for iterations in the loop. You should
 // set the increment so that the number of steps needed to overshoot the
 // target is much smaller than giveUpWhen. 
 // This is defensive coding.
 // If you leave out this parameter, expect to reboot the system frequently
 // as the script can go into an infinite loop.
 
 int giveUpWhen = 100;
 
 // Ensure that the increment moves you towards the target. In a non-trivial
 // example, this part of the code can be quite tricky. In this example, no code
 // is needed, as the result is initially less than the target.
 
 if (result >= target)
 {
 
 }
 
 // There are two loops.
 // The inner loop adds the increment to the currentT until the result
 // overshoots the target.
 // The outer loop implements a binary search. It divides increment by 2
 // (any number greater than one will work) and restarts the inner loop
 // from currenT, which is the last position before overshooting.
 
 // The initial increment will be divided at the start of the outer loop.
 
 increment = increment * 2;
 
 while (incrementSubdivided < giveUpWhen && increment > closeEnough)
 {
 // 
 incrementSubdivided = incrementSubdivided + 1;
 increment = increment / 2;
 
 // Reset incrementAdded so that the inner loop starts counting at zero.
 
 incrementAdded = 0;
 
 while ( result < target && incrementAdded < giveUpWhen)
 {
 incrementAdded = incrementAdded +1;
 currentT = driver.T;
 driver.ByParameterAlongCurve(trackLine, currentT+increment);
 
 // UpdateGraph causes the constraint system to recompute new values for
 // all features, thus computing one cycle of the search.   
 
 UpdateGraph();
 result = driver.T;
 }
 
 // The search has now overshot the target. Start again just before the
 // overshot with a smaller increment.
 
 driver.ByParameterAlongCurve(trackLine, currentT);
 
 // This call to UpdateGraph is needed as we have just returned to a
 // previous state.
 
 UpdateGraph();
 result = driver.T;
 }
 }