code: def _construct_simple(coeffs, opt):
      """Handle simple domains, e.g.: ZZ, QQ, RR and algebraic domains."""
      rationals = floats = complexes = algebraics = False
      float_numbers = []
  
      if opt.extension is True:
          is_algebraic = (
              lambda coeff: coeff.is_number and coeff.is_algebraic
          )
      else:
          is_algebraic = lambda coeff: False
  
      for coeff in coeffs:
          if coeff.is_Rational:
              if not coeff.is_Integer:
                  rationals = True
          elif coeff.is_Float:
              if algebraics:
                  # there are both reals and algebraics -> EX
                  return False
              else:
                  floats = True
                  float_numbers.append(coeff)
          else:
              is_complex = pure_complex(coeff)
              if is_complex:
                  complexes = True
                  x, y = is_complex
                  if x.is_Rational and y.is_Rational:
                      if not (x.is_Integer and y.is_Integer):
                          rationals = True
                      continue
                  else:
                      floats = True
                      if x.is_Float:
                          float_numbers.append(x)
                      if y.is_Float:
                          float_numbers.append(y)
              elif is_algebraic(coeff):
                  if floats:
                      # there are both algebraics and reals -> EX
                      return False
                  algebraics = True
              else:
                  # this is a composite domain, e.g. ZZ[X], EX
                  return None
  
      # Use the maximum precision of all coefficients for the RR or CC
      # precision
      max_prec = (
          max(c._prec for c in float_numbers) if float_numbers else 53
      )
  
      if algebraics:
          domain, result = _construct_algebraic(coeffs, opt)
      else:
          if floats and complexes:
              domain = ComplexField(prec=max_prec)
          elif floats:
              domain = RealField(prec=max_prec)
          elif rationals or opt.field:
              domain = QQ_I if complexes else QQ
          else:
              domain = ZZ_I if complexes else ZZ
  
          result = [domain.from_sympy(coeff) for coeff in coeffs]
  
      return domain, result
  
file_path: sympy/sympy/polys/constructor.py
imports: from math import prod
  from sympy.core import sympify
  from sympy.core.evalf import pure_complex
  from sympy.core.sorting import ordered
  from sympy.polys.domains import ZZ, QQ, ZZ_I, QQ_I, EX
  from sympy.polys.domains.complexfield import ComplexField
  from sympy.polys.domains.realfield import RealField
  from sympy.polys.polyoptions import build_options
  from sympy.polys.polyutils import parallel_dict_from_basic
  from sympy.utilities import public
label_desc: Use image node_id 1 for calling a global function with example usage: _construct_simple(coeffs, opt) and returns: domain,  result, False, None, False