Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
	"strings"

)


func main() {
	solve(os.Stdin, os.Stdout)
}

type ReaderEx struct {
	baseScanner *bufio.Scanner
	words       []string
	nextWordIdx func() int
	initWordIdx func(int)
}

func NewScannerEx(stdin io.Reader) *ReaderEx {
	var this ReaderEx
	var idx int
	var wordsCnt int
	this.baseScanner = bufio.NewScanner(stdin)
	this.baseScanner.Buffer(make([]byte, 0), 1E+11)
	this.nextWordIdx = func() int {
		cur := idx
		idx = (idx + 1) % wordsCnt
		return cur
	}
	this.initWordIdx = func(wc int) {
		idx = 0
		wordsCnt = wc
	}
	return &this
}

func (me *ReaderEx) Scan(doSplit bool) (isScanned bool) {
	isScanned = me.baseScanner.Scan()
	if doSplit {
		me.words = strings.Fields(me.baseScanner.Text())
	} else {
		me.words = []string{me.baseScanner.Text()}
	}
	me.initWordIdx(len(me.words))
	return
}

func (me *ReaderEx) nextBytes() []byte {
	return []byte(me.words[me.nextWordIdx()])
}
func (me *ReaderEx) nextString() string {
	return me.words[me.nextWordIdx()]
}

type StringArray []string

func (me *ReaderEx) nextStringArray() StringArray {
	return me.words[me.nextWordIdx():]
}

func (me StringArray) toStrings() []string {
	return me
}

func (me StringArray) toInts() []int {
	strValues := me.toStrings()
	values := make([]int, len(strValues))
	for i, v := range strValues {
		n, err := strconv.Atoi(v)
		if err != nil {
			panic(err)
		}
		values[i] = n
	}
	return values
}
func (me *ReaderEx) nextInt() int {
	n, err := strconv.Atoi(me.words[me.nextWordIdx()])

	defer func() {
		if err != nil {
			panic(fmt.Sprintf("getInt(%d)", n))
		}
	}()
	return n
}

func pow(x, y, mod int) (ans int) {

	ans = 1
	for bit := 1 << uint(math.Floor(math.Log2(float64(y)))); ; bit >>= 1 {
		if y&bit != 0 {
			ans *= x
			if mod > 0 {
				ans %= mod
			}
		}
		if bit <= 1 {
			return
		}
		ans *= ans
		if mod > 0 {
			ans %= mod
		}
	}
}

type factType struct {
	prime int
	count int
}

func fact(n int) (facts []*factType) {

	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			fa := factType{prime: i}
			for n%fa.prime == 0 {
				n /= fa.prime
				fa.count++
			}
			facts = append(facts, &fa)
		}
	}
	if n > 1 {
		facts = append(facts, &factType{prime: n, count: 1})
	}
	return facts
}
func dec2bin(n int) (ret []bool) {
	for bit := 1 << uint(math.Floor(math.Log2(float64(n)))); ; bit >>= 1 {
		ret = append(ret, n&bit != 0)

		if bit <= 1 {
			return
		}
	}

}

func abs(v int) int {
	if v < 0 {
		v = -v
	}
	return v
}

func b2i(b bool) (i int) {
	if b {
		i = 1
	} else {
		i = 0
	}
	return
}

func solve(stdin io.Reader, stdout io.Writer) {

	r := NewScannerEx(stdin)
	r.Scan(true)
	n := r.nextInt()

	type Vec struct {
		x, y float64
	}
	vec := func(a, b Vec) Vec { return Vec{b.x - a.x, b.y - a.y} }
	unv := func(a Vec) Vec { return Vec{-a.y, a.x} }
	cdot := func(a, b Vec) float64 { return a.x*b.x + a.y*b.y }
	times := func(t float64, a Vec) Vec { return Vec{t * a.x, t * a.y} }
	add := func(a, b Vec) Vec { return Vec{a.x + b.x, a.y + b.y} }
	for i := 0; i < n; i++ {

		r.Scan(true)
		nextFloat64 := func() (ret float64) { fmt.Sscanf(r.nextString(), "%f", &ret); return }
		a1, a2, a3 := Vec{nextFloat64(), nextFloat64()}, Vec{nextFloat64(), nextFloat64()}, Vec{nextFloat64(), nextFloat64()}
		unv23 := unv(vec(a2, a3))
		v12 := vec(a1, a2)
		v31 := vec(a3, a1)
		s := cdot(v12, v31) / 2 / cdot(v12, unv23)
		c := add(times(.5, add(a2, a3)), times(s, unv23))
		v1c := vec(a1, c)
		fmt.Fprintf(stdout, "%.3f %.3f %.3f\n", c.x, c.y, math.Sqrt(v1c.x*v1c.x+v1c.y*v1c.y))
	}
}

C++: #include <iostream>
#include <stdio.h>

void CulculateCoordinateAndRadius(double&, double&, double&, double, double, double, double, double, double);
double slope(const double[2], const double[2]);
double n_slope(const double[2], const double[2]);
double intercept(const double, const double[2]);
double center(const double, const double);
double mySqrt(double, const int&);
double myRound(double, const int&);

int main(){

	int NumberOfDataset;  //データセットの数
	double x1, y1, x2, y2, x3, y3; //入力される座標
	double px, py, r;

	std::cin >> NumberOfDataset;

	for (int i = 0; i < NumberOfDataset; i++)
	{
		std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
		CulculateCoordinateAndRadius(px, py, r, x1, y1, x2, y2, x3, y3);
		/*px = myRound(px, 4);
		py = myRound(py, 4);
		r = myRound(r, 4);*/
		//std::cout << px << ' ' << py << ' ' << r << std::endl;
		printf("%0.3f %0.3f %0.3f\n", px, py, r);
	}
}

void CulculateCoordinateAndRadius(double& px, double&py, double&r, double x1, double y1, double x2, double y2, double x3, double y3){
	double point1[2] = { x1, y1 };
	double point2[2] = { x2, y2 };
	double point3[2] = { x3, y3 };
	double center1[2] = { center(point1[0], point2[0]), center(point1[1], point2[1]) };
	double center2[2] = { center(point2[0], point3[0]), center(point2[1], point3[1]) };
	double n_slope_1 = n_slope(point1, point2);
	double n_slope_2 = n_slope(point2, point3);
	double intercept_1 = intercept(n_slope_1, center1);
	double intercept_2 = intercept(n_slope_2, center2);
	if (y1 == y2){
		px = center1[0];
		py = n_slope_2 * px + intercept_2;
	}
	else if (y2 == y3){
		px = center2[0];
		py = n_slope_1 * px + intercept_1;
	}else{
		px = (intercept_2 - intercept_1) / (n_slope_1 - n_slope_2);
		py = n_slope_1 * px + intercept_1;
	}
	r = mySqrt((px - x1) * (px - x1) + (py - y1) * (py - y1), 5);
}


double slope(const double point1[2], const double point2[2]){
	return (point2[1] - point1[1]) / (point2[0] - point1[0]);
}

double n_slope(const double point1[2], const double point2[2]){
	double x1 = -point1[1];
	double y1 = point1[0];
	double x2 = -point2[1];
	double y2 = point2[0];
	return (y2 - y1) / (x2 - x1);
}

double intercept(const double slope, const double POINT1[2]){
	return -slope * POINT1[0] + POINT1[1];
}

double center(const double COODINATE1, const double COODINATE2){
	return (COODINATE1 + COODINATE2) / 2;
}

double mySqrt(double number, const int& SIGNIFICANT_DIGITS){
	double result = 0;
	double digitsOffset = 1;

	for (int i = 0; i < SIGNIFICANT_DIGITS + 1; i++){
		while (number >= (result + digitsOffset) * (result + digitsOffset)){
			result += digitsOffset;
		}
		digitsOffset /= 10;
	}
	return result;
}

double myRound(double number, const int& SIGNIFICANT_DIGITS){
	for (int i = 0; i < SIGNIFICANT_DIGITS; i++){
		number *= 10;
	}
	int targetDigits = static_cast<int>(number) % 10;
	if (targetDigits >= 5){
		number = static_cast<int>(number) + 10 - targetDigits;
	}
	else{
		number = static_cast<int>(number) - targetDigits;
	}
	for (int i = 0; i < SIGNIFICANT_DIGITS; i++){
		number /= 10;
	}
	return number;
}

C++: // AOJ 0010 (http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0010&lang=jp)
#include<cstdio>
#include<cmath>
#define rep(i,a) for(int i=0;i<(a);++i)

int n;

double sqr( double x )
{ return x*x; }

int main()
{
	scanf( "%d", &n );
	while( n-- )
	{
		double x1, y1, x2, y2, x3, y3;
		scanf( "%lf%lf%lf%lf%lf%lf", &x1, &y1, &x2, &y2, &x3, &y3 );

		double a = sqrt(sqr(x3-x2)+sqr(y3-y2)), b = sqrt(sqr(x1-x3)+sqr(y1-y3)), c = sqrt(sqr(x2-x1)+sqr(y2-y1));
		double cosA = (sqr(b)+sqr(c)-sqr(a))/(2*b*c), cosB = (sqr(c)+sqr(a)-sqr(b))/(2*c*a), cosC = (sqr(a)+sqr(b)-sqr(c))/(2*a*b);
		double sinA = sqrt(1-sqr(cosA)), sinB = sqrt(1-sqr(cosB)), sinC = sqrt(1-sqr(cosC));
		double sin2A = 2*sinA*cosA, sin2B = 2*sinB*cosB, sin2C = 2*sinC*cosC;
		double px = (sin2A*x1+sin2B*x2+sin2C*x3)/(sin2A+sin2B+sin2C), py = (sin2A*y1+sin2B*y2+sin2C*y3)/(sin2A+sin2B+sin2C);

		printf( "%.3f %.3f %.3f\n", px, py, sqrt(sqr(x1-px)+sqr(y1-py)) );
	}

	return 0;
}