docs: def getPhenotypes(self,i0=None,i1=None,phenotype_IDs=None,geneIDs=None,environments=None,center=True,impute=True,intersection=False):
          """load Phenotypes
          
          Args:
              i0:             phenotype indices to load (start individual index)
              i1:             phenotype indices to load (stop individual index)
              phenotype_IDs:  names of phenotypes to load
              geneIDs:        names of genes to load
              environments:   names of environments to load
              impute:         imputation of missing values (default: True)
              intersection:   restrict observation to those obseved in all phenotypes? (default: False)
          
          Returns:
              Y:              phenotype values
              Ikeep:          index of individuals in Y
          """
          if phenotype_IDs is None and (geneIDs is not None or environments is not None):
             if geneIDs is None:
                 geneIDs = self.geneIDs
             elif type(geneIDs)!=list:
                 geneIDs = [geneIDs]
             if environments is None:
                 environments = self.Es
             elif type(environments)!=list:
                 environments = [environments]
             phenotype_IDs = []
             for env in environments:
                 for gene in geneIDs:
                     phenotype_IDs.append('%s:%d'%(gene,env))
  
          if phenotype_IDs is not None:
              I = SP.array([SP.nonzero(self.phenotype_ID==n)[0][0] for n in phenotype_IDs])
          else:
              I = SP.arange(self.phenotype_ID.shape[0])
          Y = SP.array(self.phenoM[:,I],dtype='float')
          Iok = (~SP.isnan(Y))
  
          if intersection:
              Ikeep = Iok.all(axis=1)
          else:
              Ikeep = Iok.any(axis=1)
  
          Y = Y[Ikeep]
          Iok = Iok[Ikeep]
  
          if center | impute:
              for i in range(Y.shape[1]):
                  ym = Y[Iok[:,i],i].mean()
                  Y[:,i]-=ym
                  Y[~Iok[:,i],i] = ym
                  Y[:,i]/=Y[:,i].std()
          #calculate overlap of missing values
          return [Y,Ikeep]