My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <iomanip>
       
#include <cmath>
       
 
       
typedef double Number; // changing it to long double gives the same results
       
 
       
// 2D point

       
struct Point
       
{
       
  // create a new point
       
  Point(Number x_, Number y_)
       
  : x(x_), y(y_) {}
       
 
       
  // return distance between two points
       
  Number distance(const Point& other) const
       
  {
       
    auto diffX = x - other.x;
       
    auto diffY = y - other.y;
       
    return sqrt(diffX * diffX + diffY * diffY);
       
  }
       
 
       
  Number x, y;
       
};
       
 
       
// interpolate between four points p0, p1, p2, p3 with parameter t

       
Point bezier(const Point& p0, const Point& p1, const Point& p2, const Point& p3, Number t)
       
{
       
  // see https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm
       
 
       
  // linear interpolation between p0 and p1, p1 and p2, p2 and p3
       
  Point q0(p0.x + (p1.x - p0.x) * t, p0.y + (p1.y - p0.y) * t);
       
  Point q1(p1.x + (p2.x - p1.x) * t, p1.y + (p2.y - p1.y) * t);
       
  Point q2(p2.x + (p3.x - p2.x) * t, p2.y + (p3.y - p2.y) * t);
       
 
       
  // rinse and repeat: linear interpolation between q0 and q1, q1 and q2
       
  Point r0(q0.x + (q1.x - q0.x) * t, q0.y + (q1.y - q0.y) * t);
       
  Point r1(q1.x + (q2.x - q1.x) * t, q1.y + (q2.y - q1.y) * t);
       
 
       
  // and finally: linear interpolation between q0 and q1, q1 and q2
       
  Point b(r0.x + (r1.x - r0.x) * t, r0.y + (r1.y - r0.y) * t);
       
 
       
  return b;
       
}
       
 
       
// same as bezier() but optimized for the case (1, 0), (1, v), (v, 1), (0, 1)

       
Point bezierArc(Number v, Number t)
       
{
       
  // direct computation of cubic Bezier curves (see https://en.wikipedia.org/wiki/B%C3%A9zier_curve ):
       
  // replace p0,p1,p2,p3 by their known values 0, 1 or v
       
  return Point(pow(1 - t, 3) + 3*pow(1 - t, 2)*t   + 3*(1 - t)*t*t*v,
       
                               3*pow(1 - t, 2)*t*v + 3*(1 - t)*t*t   + t*t*t);
       
}
       
 
       
// find length of Bezier curve between t=from and t=to with an accuracy=epsilon

       
Number getLength(Number v, Number from, Number to, Number epsilon)
       
{
       
  // compute three points: start, middle and end
       
  auto bisect = (from + to) / 2;
       
  auto start  = bezierArc(v, from);
       
  auto middle = bezierArc(v, bisect);
       
  auto end    = bezierArc(v, to);
       
 
       
  // compute distance start,end against start,middle + middle,end
       
  auto totalDistance = start.distance(end);
       
  auto firstHalf     = middle.distance(start);
       
  auto secondHalf    = middle.distance(end);
       
  auto morePrecise   = firstHalf + secondHalf;
       
  // enough accuracy ?
       
  if (morePrecise < totalDistance + epsilon)
       
    return morePrecise;
       
 
       
  // go deeper, compute start,middle + start,end more accurately
       
  return getLength(v, from, bisect, epsilon) + getLength(v, bisect, to, epsilon);
       
}
       
 
       
int main()
       
{
       
  std::cout << std::fixed << std::setprecision(10);
       
 
       
  // some pi-based constants
       
  const Number pi     = 3.14159265358979323846264338327950288419;
       
  // expected length of the arc
       
  const Number piDiv2 = pi / 2;
       
 
       
  // find v
       
  Number v = 0.5;
       
 
       
//#define FIND_V

       
#ifdef  FIND_V
       
  // expected area inside the arc
       
  const Number piDiv4 = pi / 4;
       
  // carefully adjust tolerance thresholds
       
  const Number AreaAccuracy = 0.0000000001;
       
  const Number StepT        = 0.000001;
       
 
       
  // initial adjustment of v, will become smaller after a few iterations
       
  Number step = 0.01;
       
  // true when adding "step" to "v", false when subtracting
       
  bool increment = true;
       
 
       
  while (fabs(area - piDiv4) > AreaAccuracy)
       
  {
       
    Point last(1,0);
       
    Number area = 0;
       
    for (Number t = 0; t <= 1; t += StepT)
       
    {
       
      //Point p0(1, 0);
       
      //Point p1(1, v);
       
      //Point p2(v, 1);
       
      //Point p3(0, 1);
       
      //auto current = bezier(p0, p1, p2, p3, t);
       
 
       
      // optimized (=> faster) code
       
      auto current = bezierArc(v, t);
       
 
       
      // "last" is on the right side of "current": last.x > current.x
       
      auto diffX = last.x - current.x;
       
      auto diffY = last.y - current.y;
       
      area += current.y * diffX;
       
      last  = current;
       
    }
       
 
       
    // reduce deviation by adjusting v
       
    if (area < piDiv4)
       
    {
       
      // change direction ? reduce "step"
       
      if (!increment)
       
      {
       
        step /= 2;
       
        increment = true;
       
      }
       
 
       
      // increase v
       
      v += step;
       
    }
       
    else
       
    {
       
      // change direction ? reduce "step"
       
      if (increment)
       
      {
       
        step /= 2;
       
        increment = false;
       
      }
       
 
       
      // decrease v
       
      v -= step;
       
    }
       
  }
       
  std::cout << "v=" << v << std::endl;
       
#endif
       
 
       
  // pretty exact value of v
       
  v = 0.551778477804467717845437407295027163650331289;
       
 
       
  // compute length of the arc
       
  auto epsilon = 0.00000000000000001; // found manually (I tried several values until error stabilized)
       
  auto length = getLength(v, 0, 1, epsilon);
       
  auto error  = 100 * (length - piDiv2) / piDiv2;
       
  std::cout << error << std::endl;
       
  return 0;
       
}

This solution contains 26 empty lines, 38 comments and 5 preprocessor commands.