def computeStatistics(tped, tfam, samples, oldSamples, prefix):
    """Computes the completion and concordance of each samples.

    :param tped: the ``tped`` containing duplicated samples.
    :param tfam: the ``tfam`` containing duplicated samples.
    :param samples: the updated position of the samples in the tped containing
                    only duplicated samples.
    :param oldSamples: the original duplicated sample positions.
    :param prefix: the prefix of all the files.

    :type tped: :py:class:`numpy.array`
    :type tfam: :py:class:`numpy.array`
    :type samples: dict
    :type oldSamples: dict
    :type prefix: str

    :returns: a tuple containing the completion (:py:class:`numpy.array`) as
              first element, and the concordance (:py:class:`dict`) as last
              element.

    Reads the ``tped`` file and compute the completion for each duplicated
    samples and the pairwise concordance between duplicated samples.

    .. note::
        The completion and concordance computation excludes a markers if it's
        on chromosome 24 and if the sample is a female.

    .. note::
        A missing genotype is encoded by ``0``.

    .. note::
        No percentage is computed here, only the numbers. Percentages are
        computing in other functions: :py:func:`printStatistics`, for
        completion, and :py:func:`printConcordance`, for concordance.


    **Completion**

    Computes the completion of none zero values (where all genotypes of at
    least one duplicated sample are no call [*i.e.* ``0``]). The completion of
    sample :math:`i` (*i.e.* :math:`Comp_i`) is the number of genotypes
    that have a call divided by the total number of genotypes (the set
    :math:`G_i`):

    .. math::
        Comp_i = \\frac{||g \\in G_i\\textrm{ where }g \\neq 0||}{||G_i||}

    .. note::
        We consider a genotype as being missing if the sample is a male and if
        a marker on chromosome 23 or 24 is heterozygous.


    **Concordance**

    Computes the pairwise concordance between duplicated samples. For each
    marker, if both genotypes are not missing, we add one to the total number
    of compared markers. If both genotypes are the same, we add one to the
    number of concordant calls. We write the observed genotype difference in
    the file ``prefix.diff``. The concordance between sample :math:`i` and
    :math:`j` (*i.e.* :math:`Concordance_{i,j}`) is the number of genotypes
    that are equal divided by the total number of genotypes (excluding the no
    calls):

    .. math::
        Concordance_{i,j} = \\frac{
            ||g \\in G_i \\cup G_j \\textrm{ where } g_i = g_j \\neq 0||
        }{
            ||g \\in G_i \\cup G_j \\textrm{ where } g \\neq 0||
        }

    """
    # The diff file containing the genotype differences between a pair of
    # duplicated samples
    diffOutput = None
    try:
        diffOutput = open(prefix + ".diff", "w")
    except IOError:
        msg = "%(prefix)s.diff: can't write file" % locals()
        raise ProgramError(msg)
    print >>diffOutput, "\t".join(["name", "famID", "indID", "dupIndex_1",
                                   "dupIndex_2", "genotype_1", "genotype_2"])

    # The completion data type
    completion = np.array([[0 for i in xrange(len(tped[0][4:]))],
                           [0 for i in xrange(len(tped[0][4:]))]])

    # The concordance data type
    concordance = {}
    for sampleID in samples.keys():
        nbDup = len(samples[sampleID])
        concordance[sampleID] = [
            np.asmatrix(np.zeros((nbDup, nbDup), dtype=int)),
            np.asmatrix(np.zeros((nbDup, nbDup), dtype=int)),
        ]

    #####################################################################
    # Add options for concordance only for hetero SNPs... (all samples) #
    #####################################################################

    for row in tped:
        genotype = row[4:]
        chromosome = row[0]
        snpName = row[1]
        for key, indexes in samples.iteritems():
            for i, index in enumerate(indexes):
                sex = tfam[oldSamples[key][i]][4]
                genotype1 = set(genotype[index].split(" "))

                # Updating the completion
                if not ((chromosome == "24") and (sex == "2")):
                    if (sex == "1") and (chromosome in ["23", "24"]):
                        if ("0" not in genotype1) and (len(genotype1) != 2):
                            completion[0][index] += 1
                    elif "0" not in genotype1:
                        completion[0][index] += 1
                    completion[1][index] += 1

                    # Updating the concordance
                    for j in xrange(i + 1, len(indexes)):
                        genotype2 = set(genotype[indexes[j]].split(" "))

# This is for man on chr 23 and 24, if heterozygous!!! #
# if (sex == "1") and (chromosome in ["23", "24"]):
#     if ("0" not in genotype1) and ("0" not in genotype2):
#         if (len(genotype1) != 2) and (len(genotype2) != 2):
#             concordance[key][1][i,j] += 1
#             concordance[key][1][j,i] += 1
#             if genotype1 == genotype2:
#                 concordance[key][0][i,j] += 1
#                 concordance[key][0][j,i] += 1
#             else:
#                 # Print to diff file
#                 toPrint = [snpName, key[0], key[1],
#                            str(index+1),
#                            str(indexes[j]+1)]
#                 toPrint.append(" ".join(genotype1))
#                 if len(genotype1) == 1:
#                     toPrint[-1] += " %s" % toPrint[-1]
#                 toPrint.append(" ".join(genotype2))
#                 if len(genotype2) == 1:
#                     toPrint[-1] += " %s" % toPrint[-1]
#                 print >>diffOutput, "\t".join(toPrint)
#
# elif ("0" not in genotype1) and ("0" not in genotype2):

                        if ("0" not in genotype1) and ("0" not in genotype2):
                            # Both have calls
                            concordance[key][1][i, j] += 1
                            concordance[key][1][j, i] += 1
                            if genotype1 == genotype2:
                                concordance[key][0][i, j] += 1
                                concordance[key][0][j, i] += 1
                            else:
                                # Print to diff file
                                toPrint = [snpName, key[0], key[1],
                                           str(index+1), str(indexes[j]+1)]
                                toPrint.append(" ".join(genotype1))
                                if len(genotype1) == 1:
                                    toPrint[-1] += " %s" % toPrint[-1]
                                toPrint.append(" ".join(genotype2))
                                if len(genotype2) == 1:
                                    toPrint[-1] += " %s" % toPrint[-1]
                                print >>diffOutput, "\t".join(toPrint)

    diffOutput.close()

    for key in concordance.iterkeys():
        for i in range(len(concordance[key][0])):
            concordance[key][0][i, i] = 1
            concordance[key][1][i, i] = 1

    return completion, concordance