docs: def findFlippedSNPs(frqFile1, frqFile2, outPrefix):
      """Find flipped SNPs and flip them in the data.
  
      :param frqFile1: the name of the first frequency file.
      :param frqFile2: the name of the second frequency file.
      :param outPrefix: the prefix of the output files.
  
      :type frqFile1: str
      :type frqFile2: str
      :type outPrefix: str
  
      By reading two frequency files (``frqFile1`` and ``frqFile2``), it finds a
      list of markers that need to be flipped so that the first file becomes
      comparable with the second one. Also finds marker that need to be removed.
  
      A marker needs to be flipped in one of the two data set if the two markers
      are not comparable (same minor allele), but become comparable if we flip
      one of them.
  
      A marker will be removed if it is all homozygous in at least one data set.
      It will also be removed if it's impossible to determine the phase of the
      marker (*e.g.* if the two alleles are ``A`` and ``T`` or ``C`` and ``G``).
  
      """
      allelesFiles = [{}, {}]
      files = [frqFile1, frqFile2]
      for k, fileName in enumerate(files):
          try:
              with open(fileName, "r") as inputFile:
                  headerIndex = None
                  for i, line in enumerate(inputFile):
                      row = createRowFromPlinkSpacedOutput(line)
  
                      if i == 0:
                          # This is the header
                          headerIndex = dict([
                              (row[j], j) for j in xrange(len(row))
                          ])
  
                          # Checking the columns
                          for columnName in ["SNP", "A1", "A2"]:
                              if columnName not in headerIndex:
                                  msg = "%(fileName)s: no column named " \
                                        "%(columnName)s" % locals()
                                  raise ProgramError(msg)
                      else:
                          snpName = row[headerIndex["SNP"]]
                          allele1 = row[headerIndex["A1"]]
                          allele2 = row[headerIndex["A2"]]
  
                          alleles = set([allele1, allele2])
                          if "0" in alleles:
                              alleles.remove("0")
  
                          allelesFiles[k][snpName] = alleles
          except IOError:
              msg = "%(fileName)s: no such file" % locals()
              raise ProgramError(msg)
  
      allelesFile1, allelesFile2 = allelesFiles
  
      # Finding the SNPs to flip
      toFlipOutputFile = None
      try:
          toFlipOutputFile = open(outPrefix + ".snp_to_flip_in_reference", "w")
      except IOError:
          msg = "%(outPrefix)s.snp_to_flip_in_reference: can't write " \
                "file" % locals()
          raise ProgramError(msg)
  
      toRemoveOutputFile = None
      try:
          toRemoveOutputFile = open(outPrefix + ".snp_to_remove", "w")
      except IOError:
          msg = "%(outPrefix)s.snp_to_remove: can't write file" % locals()
          raise ProgramError(msg)
  
      for snpName in allelesFile1.iterkeys():
          alleles1 = allelesFile1[snpName]
          alleles2 = allelesFile2[snpName]
  
          if (len(alleles1) == 2) and (len(alleles2) == 2):
              # Both are heterozygous
              if ({"A", "T"} == alleles1) or ({"C", "G"} == alleles1) or \
                      ({"A", "T"} == alleles2) or ({"C", "G"} == alleles2):
                  # We can't flip those..., so we remove them
                  print >>toRemoveOutputFile, snpName
              else:
                  if alleles1 != alleles2:
                      # Let's try the flip one
                      if flipGenotype(alleles1) == alleles2:
                          # We need to flip it
                          print >>toFlipOutputFile, snpName
                      else:
                          # Those SNP are discordant...
                          print >>toRemoveOutputFile, snpName
          else:
              # We want to remove this SNP, because there is at least one
              # homozygous individual
              print >>toRemoveOutputFile, snpName
  
      # Closing output files
      toFlipOutputFile.close()
      toRemoveOutputFile.close()