code: def test_dragon4(self):
      # these tests are adapted from Ryan Juckett's dragon4 implementation,
      # see dragon4.c for details.
  
      fpos32 = lambda x, **k: np.format_float_positional(
          np.float32(x), **k
      )
      fsci32 = lambda x, **k: np.format_float_scientific(
          np.float32(x), **k
      )
      fpos64 = lambda x, **k: np.format_float_positional(
          np.float64(x), **k
      )
      fsci64 = lambda x, **k: np.format_float_scientific(
          np.float64(x), **k
      )
  
      preckwd = lambda prec: {"unique": False, "precision": prec}
  
      assert_equal(fpos32("1.0"), "1.")
      assert_equal(fsci32("1.0"), "1.e+00")
      assert_equal(fpos32("10.234"), "10.234")
      assert_equal(fpos32("-10.234"), "-10.234")
      assert_equal(fsci32("10.234"), "1.0234e+01")
      assert_equal(fsci32("-10.234"), "-1.0234e+01")
      assert_equal(fpos32("1000.0"), "1000.")
      assert_equal(fpos32("1.0", precision=0), "1.")
      assert_equal(fsci32("1.0", precision=0), "1.e+00")
      assert_equal(fpos32("10.234", precision=0), "10.")
      assert_equal(fpos32("-10.234", precision=0), "-10.")
      assert_equal(fsci32("10.234", precision=0), "1.e+01")
      assert_equal(fsci32("-10.234", precision=0), "-1.e+01")
      assert_equal(fpos32("10.234", precision=2), "10.23")
      assert_equal(fsci32("-10.234", precision=2), "-1.02e+01")
      assert_equal(
          fsci64("9.9999999999999995e-08", **preckwd(16)),
          "9.9999999999999995e-08",
      )
      assert_equal(
          fsci64("9.8813129168249309e-324", **preckwd(16)),
          "9.8813129168249309e-324",
      )
      assert_equal(
          fsci64("9.9999999999999694e-311", **preckwd(16)),
          "9.9999999999999694e-311",
      )
  
      # test rounding
      # 3.1415927410 is closest float32 to np.pi
      assert_equal(
          fpos32("3.14159265358979323846", **preckwd(10)),
          "3.1415927410",
      )
      assert_equal(
          fsci32("3.14159265358979323846", **preckwd(10)),
          "3.1415927410e+00",
      )
      assert_equal(
          fpos64("3.14159265358979323846", **preckwd(10)),
          "3.1415926536",
      )
      assert_equal(
          fsci64("3.14159265358979323846", **preckwd(10)),
          "3.1415926536e+00",
      )
      # 299792448 is closest float32 to 299792458
      assert_equal(
          fpos32("299792458.0", **preckwd(5)), "299792448.00000"
      )
      assert_equal(fsci32("299792458.0", **preckwd(5)), "2.99792e+08")
      assert_equal(
          fpos64("299792458.0", **preckwd(5)), "299792458.00000"
      )
      assert_equal(fsci64("299792458.0", **preckwd(5)), "2.99792e+08")
  
      assert_equal(
          fpos32("3.14159265358979323846", **preckwd(25)),
          "3.1415927410125732421875000",
      )
      assert_equal(
          fpos64("3.14159265358979323846", **preckwd(50)),
          "3.14159265358979311599796346854418516159057617187500",
      )
      assert_equal(
          fpos64("3.14159265358979323846"), "3.141592653589793"
      )
  
      # smallest numbers
      assert_equal(
          fpos32(0.5 ** (126 + 23), unique=False, precision=149),
          "0.00000000000000000000000000000000000000000000140129846432"
          "4817070923729583289916131280261941876515771757068283889791"
          "08268586060148663818836212158203125",
      )
  
      assert_equal(
          fpos64(5e-324, unique=False, precision=1074),
          "0.00000000000000000000000000000000000000000000000000000000"
          "0000000000000000000000000000000000000000000000000000000000"
          "0000000000000000000000000000000000000000000000000000000000"
          "0000000000000000000000000000000000000000000000000000000000"
          "0000000000000000000000000000000000000000000000000000000000"
          "0000000000000000000000000000000000049406564584124654417656"
          "8792868221372365059802614324764425585682500675507270208751"
          "8652998363616359923797965646954457177309266567103559397963"
          "9877479601078187812630071319031140452784581716784898210368"
          "8718636056998730723050006387409153564984387312473397273169"
          "6151400317153853980741262385655911710266585566867681870395"
          "6031062493194527159149245532930545654440112748012970999954"
          "1931989409080416563324524757147869014726780159355238611550"
          "1348035264934720193790268107107491703332226844753335720832"
          "4319360923828934583680601060115061698097530783422773183292"
          "4790498252473077637592724787465608477820373446969953364701"
          "7972677717585125660551199131504891101451037862738167250955"
          "8373897335989936648099411642057026370902792427675445652290"
          "87538682506419718265533447265625",
      )
  
      # largest numbers
      f32x = np.finfo(np.float32).max
      assert_equal(
          fpos32(f32x, **preckwd(0)),
          "340282346638528859811704183484516925440.",
      )
      assert_equal(
          fpos64(np.finfo(np.float64).max, **preckwd(0)),
          "1797693134862315708145274237317043567980705675258449965989"
          "1747680315726078002853876058955863276687817154045895351438"
          "2464234321326889464182768467546703537516986049910576551282"
          "0762454900903893289440758685084551339423045832369032229481"
          "6580855933212334827479782620414472316873817718091929988125"
          "0404026184124858368.",
      )
      # Warning: In unique mode only the integer digits necessary for
      # uniqueness are computed, the rest are 0.
      assert_equal(
          fpos32(f32x), "340282350000000000000000000000000000000."
      )
  
      # Further tests of zero-padding vs rounding in different combinations
      # of unique, fractional, precision, min_digits
      # precision can only reduce digits, not add them.
      # min_digits can only extend digits, not reduce them.
      assert_equal(
          fpos32(f32x, unique=True, fractional=True, precision=0),
          "340282350000000000000000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=True, precision=4),
          "340282350000000000000000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=True, min_digits=0),
          "340282346638528859811704183484516925440.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=True, min_digits=4),
          "340282346638528859811704183484516925440.0000",
      )
      assert_equal(
          fpos32(
              f32x,
              unique=True,
              fractional=True,
              min_digits=4,
              precision=4,
          ),
          "340282346638528859811704183484516925440.0000",
      )
      assert_raises(
          ValueError,
          fpos32,
          f32x,
          unique=True,
          fractional=False,
          precision=0,
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=False, precision=4),
          "340300000000000000000000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=False, precision=20),
          "340282350000000000000000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=False, min_digits=4),
          "340282350000000000000000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=False, min_digits=20),
          "340282346638528859810000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=True, fractional=False, min_digits=15),
          "340282346638529000000000000000000000000.",
      )
      assert_equal(
          fpos32(f32x, unique=False, fractional=False, precision=4),
          "340300000000000000000000000000000000000.",
      )
      # test that unique rounding is preserved when precision is supplied
      # but no extra digits need to be printed (gh-18609)
      a = np.float64.fromhex("-1p-97")
      assert_equal(fsci64(a, unique=True), "-6.310887241768095e-30")
      assert_equal(
          fsci64(a, unique=False, precision=15),
          "-6.310887241768094e-30",
      )
      assert_equal(
          fsci64(a, unique=True, precision=15), "-6.310887241768095e-30"
      )
      assert_equal(
          fsci64(a, unique=True, min_digits=15),
          "-6.310887241768095e-30",
      )
      assert_equal(
          fsci64(a, unique=True, precision=15, min_digits=15),
          "-6.310887241768095e-30",
      )
      # adds/remove digits in unique mode with unbiased rnding
      assert_equal(
          fsci64(a, unique=True, precision=14), "-6.31088724176809e-30"
      )
      assert_equal(
          fsci64(a, unique=True, min_digits=16),
          "-6.3108872417680944e-30",
      )
      assert_equal(
          fsci64(a, unique=True, precision=16), "-6.310887241768095e-30"
      )
      assert_equal(
          fsci64(a, unique=True, min_digits=14),
          "-6.310887241768095e-30",
      )
      # test min_digits in unique mode with different rounding cases
      assert_equal(fsci64("1e120", min_digits=3), "1.000e+120")
      assert_equal(fsci64("1e100", min_digits=3), "1.000e+100")
  
      # test trailing zeros
      assert_equal(fpos32("1.0", unique=False, precision=3), "1.000")
      assert_equal(fpos64("1.0", unique=False, precision=3), "1.000")
      assert_equal(
          fsci32("1.0", unique=False, precision=3), "1.000e+00"
      )
      assert_equal(
          fsci64("1.0", unique=False, precision=3), "1.000e+00"
      )
      assert_equal(fpos32("1.5", unique=False, precision=3), "1.500")
      assert_equal(fpos64("1.5", unique=False, precision=3), "1.500")
      assert_equal(
          fsci32("1.5", unique=False, precision=3), "1.500e+00"
      )
      assert_equal(
          fsci64("1.5", unique=False, precision=3), "1.500e+00"
      )
      # gh-10713
      assert_equal(
          fpos64("324", unique=False, precision=5, fractional=False),
          "324.00",
      )
  
file_path: catboost/contrib/python/numpy/py3/numpy/core/tests/test_scalarprint.py
imports: import code
  import platform
  import pytest
  import sys
  from tempfile import TemporaryFile
  import numpy
  from numpy.testing import assert_, assert_equal, assert_raises, IS_MUSL
label_desc: Use image node_id 4 for calling the TestRealScalars obj's underlying member method code with example usage: obj.test_dragon4() without return types