Go: package main

import (
	"fmt"
	"math"
)

func main() {
	n := scanInt()
	for i := 0; i < n; i++ {
		cal()
	}
}

func scanInt() int {
	var n int
	fmt.Scanf("%d", &n)
	return n
}

func cal() {
	var x1, y1, x2, y2, x3, y3 float64
	fmt.Scanf("%f%f%f%f%f%f", &x1, &y1, &x2, &y2, &x3, &y3)
	a := 2 * (x1 - x2)
	b := 2 * (y1 - y2)
	c := 2 * (x1 - x3)
	d := 2 * (y1 - y3)
	e := x1*x1 - x2*x2 + y1*y1 - y2*y2
	f := x1*x1 - x3*x3 + y1*y1 - y3*y3

	px := (d*e - b*f) / (a*d - b*c)
	py := (a*f - c*e) / (a*d - b*c)

	r := math.Sqrt((x1-px)*(x1-px) + (y1-py)*(y1-py))
	fmt.Printf("%.3f %.3f %.3f\n", px, py, r)
}

C++: #include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>

using namespace std;

struct point{
    double x;
    double y;
};

struct linear{
    double a;
    double b;
    double c;
};

linear get_linear(point a, point b){
    linear l;

    if(a.x == b.x){
        l.a = 1;
        l.b = 0;
        l.c = a.x;
    }else if(a.y == b.y){
        l.a = 0;
        l.b = 1;
        l.c = a.y;
    }else{
        l.a = (b.x-a.x)/(b.y-a.y);
        l.b = -1;
        l.c = a.x * l.a - a.y;
    }
    return l;
}

linear get_linear_vertical(point p, linear l){
    linear lv;
    lv.a = (-1)*l.b;
    lv.b = l.a;
    lv.c = lv.a*p.x + lv.b*p.y;
    return lv;
}

point get_cross_point(linear l1, linear l2){
    point p;
    p.x = (l1.b*l2.c - l1.c*l2.b)/(l1.b*l2.a - l1.a*l2.b);
    p.y = (l1.c*l2.a - l1.a*l2.c)/(l1.b*l2.a - l1.a*l2.b);
    return p;
}

double round3dig(double d){
    d *= 1000;
    d += (0.5 - (d < 0));
    d = int(d);
    if(d != 0)
        d /= 1000;
    return d;
}

double point_distance(point s, point e){
    double d;
    d = pow(e.x - s.x, 2)+pow(e.y - s.y, 2);
    d = sqrt(d);
    return d;
}

int main()
{
    int n;
    double r;
    point p[3], mp, cp;
    linear l1, l2;

    cin >> n;
    vector< point > v[n];
    for(int i = 0; i < n; ++i){
        cin >> p[0].x >> p[0].y >> p[1].x >> p[1].y >> p[2].x >> p[2].y;
        v[i].push_back(p[0]);
        v[i].push_back(p[1]);
        v[i].push_back(p[2]);
    }
    for(int i = 0; i < n; ++i){
        l1 = get_linear(v[i].at(0), v[i].at(1));
        mp.x = (v[i].at(1).x - v[i].at(0).x)/2;
        mp.y = (v[i].at(1).y - v[i].at(0).y)/2;
        l1 = get_linear_vertical(mp, l1);

        l2 = get_linear(v[i].at(0), v[i].at(2));
        mp.x = (v[i].at(2).x - v[i].at(0).x)/2;
        mp.y = (v[i].at(2).y - v[i].at(0).y)/2;
        l2 = get_linear_vertical(mp, l2);

        cp = get_cross_point(l1, l2);
        r = point_distance(v[i].at(0), cp);

        cp.x = round3dig(cp.x);
        cp.y = round3dig(cp.y);
        r = round3dig(r);

        cout << fixed << setprecision(3)
             << cp.x << ' ' << cp.y << ' ' << r << endl;
    }
    return 0;
}

C++: #include<iostream>
#include<string>
#include<sstream>
#include<cmath>
using namespace std;

double fpx(double a, double b, double c, double d, double e, double f);
double fpy(double a, double b, double c, double d, double e, double f);
double  fr(double a, double b, double c, double d);
string toStr(double a);
string intToString(int a);

int main() {
  int n;
  double x1, y1, x2, y2, x3, y3;

  cin >> n;
  
  for (int i = 0; i < n; i++) {
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
    double px = fpx(x1, y1, x2, y2, x3, y3);
    double py = fpy(x1, y1, x2, y2, x3, y3);
    double  r =  fr(x1, y1, px, py);

    cout << toStr(px) << " " << toStr(py) << " " << toStr(r) << endl;
  }
}


double fpx(double x1, double y1, double x2, double y2, double x3, double y3) {
  double a1, a2, b1, b2, c1, c2;

  a1 = 2 * (x2 - x1);
  b1 = 2 * (y2 - y1);
  c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;

  a2 = 2 * (x3 - x1);
  b2 = 2 * (y3 - y1);
  c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;

  return (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
}

double fpy(double x1, double y1, double x2, double y2, double x3, double y3) {
  double a1, a2, b1, b2, c1, c2;

  a1 = 2 * (x2 - x1);
  b1 = 2 * (y2 - y1);
  c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;

  a2 = 2 * (x3 - x1);
  b2 = 2 * (y3 - y1);
  c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;

  return (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);
}

double fr(double x1, double y1, double x2, double y2) {
  return sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) );
}

string toStr(double d) {
  string pm = "", val = "";
  if (d < 0) {
    pm = "-";
    d = -d;
  }

  int ipart = (int)d;
  int fpart = (int)( (d - (double)ipart) * 10000) + 10005;

  val = pm + intToString(ipart) + "." + intToString(fpart).substr(1, 3);
  return val;
}

string intToString(int n) {
  stringstream ss;
  ss << n;
  return ss.str();
}

C++: #include <iostream>
#include <cmath>
#include <cstdio>

int main()
{
	int n;
	std::cin >> n;
	for(int i = 0; i < n; ++i)
	{
		double x1,y1,x2,y2,x3,y3;
		std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;

		double const a = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));	
		double const b = sqrt((x3-x2)*(x3-x2) + (y3-y2)*(y3-y2));
		double const c = sqrt((x3-x1)*(x3-x1) + (y3-y1)*(y3-y1));

		double const cosA = (b*b+c*c-a*a)/(2*b*c);
		double const cosB = (a*a+c*c-b*b)/(2*a*c);
		double const cosC = (a*a+b*b-c*c)/(2*a*b);
		double const sinA = sqrt(1-cosA*cosA);

		double const r = a / (sinA * 2);
		//std::cout << "r = " << r << std::endl;

		//std::cout << "cosA = " << cosA << std::endl;
		//std::cout << "cosB = " << cosB << std::endl;
		//std::cout << "cosC = " << cosC << std::endl;

		if(-0.001 < cosA && cosA < 0.001) std::printf("%.3lf %.3lf", (x1+x2) / 2 , (y1+y2) / 2);
		else if (-0.001 < cosB && cosB < 0.001) std::printf("%.3lf %.3lf", (x2+x3) / 2 ,(y2+y3) / 2);
		else if (-0.001 < cosC && cosC < 0.001) std::printf("%.3lf %.3lf", (x1+x3) / 2 , (y1+y3) / 2);
		else
		{
			double const h = sqrt(r*r-(c/2)*(c/2));
				
			//std::cout << "c = " << c << std::endl;
			std::cout << "h = " << h << std::endl;
			
			double const xm = (x1+x3)/2;
			double const ym = (y1+y3)/2;
			std::cout << "xm = " << xm << " ym = " << ym << std::endl;

			double const sinD = (y1-y3) / sqrt((x3-x1)*(x3-x1) + (y3-y1)*(y3-y1));
			double const cosD = (x1-x3) / sqrt((x3-x1)*(x3-x1) + (y3-y1)*(y3-y1));
			std::cout << "sinD = " << sinD << " cosD = " << cosD << std::endl;

			double y4 = h * cosD;
			double x4 = h * sinD;
			std::cout << "x4 = " << x4 << " y4 = " << y4 << std::endl;

			if((sinD < 0 && cosD < 0) || (sinD > 0 && cosD < 0)) x4 *= -1;
			if((sinD == 0 && cosD < 0) || (sinD > 0 && cosD > 0) || (sinD < 0 && cosD > 0)) y4 *= -1;

			double const xd = xm + x4;
			double const yd = ym + y4;


			std::cout << xd << " " << yd;
		}
		std::printf(" %.3lf\n", r);
	}
	return 0;
}

C++: 
/*
 * main.cpp
 *
 *  Created on: 2011/04/08
 *      Author: satoki
 *      13:00 ~
 */
#include <iostream>
#include <string.h>
using namespace std;

int iN;
double dX[3];
double dY[3];

double dXp;
double dYp;
double dRp;

void init() {
  scanf("%d", &iN);
}

bool input() {
  scanf("%lf %lf %lf %lf %lf %lf"
      , &dX[0], &dY[0], &dX[1], &dY[1], &dX[2], &dY[2]);
  return true;
}

void manage() {

}

int main() {
  int i;
  init();
  for (i = 0; i < iN; i++) {
    input();
    manage();
    printf("%.3f %.3f %.3f\n", dXp, dYp, dRp);
  }
  return 0;
}