Exemple #1
0
 def test_oadev_ci(self):
     s32rows = testutils.read_stable32(resultfile='oadev_octave.txt',
                                       datarate=1.0)
     for row in s32rows:
         data = testutils.read_datafile(data_file)
         data = allan.frequency2fractional(data, mean_frequency=1.0e7)
         (taus, devs, errs, ns) = allan.oadev(data,
                                              rate=rate,
                                              data_type="freq",
                                              taus=[row['tau']])
         # NOTE! Here we use alhpa from Stable32-results for the allantools edf computation!
         edf = allan.edf_greenhall(alpha=row['alpha'],
                                   d=2,
                                   m=row['m'],
                                   N=len(data),
                                   overlapping=True,
                                   modified=False,
                                   verbose=True)
         (lo, hi) = allan.confidence_interval(devs[0], edf=edf)
         print("n check: ", testutils.check_equal(ns[0], row['n']))
         print(
             "dev check: ", devs[0], row['dev'],
             testutils.check_approx_equal(devs[0],
                                          row['dev'],
                                          tolerance=2e-3))
         print(
             "min dev check: ", lo, row['dev_min'],
             testutils.check_approx_equal(lo,
                                          row['dev_min'],
                                          tolerance=2e-3))
         print(
             "max dev check: ", hi, row['dev_max'],
             testutils.check_approx_equal(hi,
                                          row['dev_max'],
                                          tolerance=2e-3))
Exemple #2
0
 def test_oadev_ci(self):
     s32rows = testutils.read_stable32(resultfile='oadev_decade.txt',
                                       datarate=1.0)
     for row in s32rows:
         data = testutils.read_datafile(data_file)
         (taus, devs, errs, ns) = allan.oadev(data,
                                              rate=rate,
                                              taus=[row['tau']])
         edf = allan.edf_greenhall(alpha=row['alpha'],
                                   d=2,
                                   m=row['m'],
                                   N=len(data),
                                   overlapping=True,
                                   modified=False,
                                   verbose=True)
         (lo, hi) = allan.confidence_intervals(devs[0],
                                               ci=0.68268949213708585,
                                               edf=edf)
         print("n check: ", testutils.check_equal(ns[0], row['n']))
         print("dev check: ",
               testutils.check_approx_equal(devs[0], row['dev']))
         print(
             "min dev check: ", lo, row['dev_min'],
             testutils.check_approx_equal(lo,
                                          row['dev_min'],
                                          tolerance=1e-3))
         print(
             "max dev check: ", hi, row['dev_max'],
             testutils.check_approx_equal(hi,
                                          row['dev_max'],
                                          tolerance=1e-3))
Exemple #3
0
    def test_totdev_ci(self):
        print("totdev()")
        s32rows = testutils.read_stable32(resultfile='totdev_octave.txt',
                                          datarate=1.0)
        for row in s32rows:
            data = testutils.read_datafile(data_file)
            data = allan.frequency2fractional(data, mean_frequency=1.0e7)
            (taus, devs, errs, ns) = allan.totdev(data,
                                                  rate=rate,
                                                  data_type="freq",
                                                  taus=[row['tau']])
            edf = allan.edf_totdev(N=len(data), m=row['m'], alpha=row['alpha'])

            (lo, hi) = allan.confidence_interval(devs[0], edf=edf)
            print("n check: ", testutils.check_equal(ns[0], row['n']))
            print(
                "dev check: ",
                testutils.check_approx_equal(devs[0],
                                             row['dev'],
                                             tolerance=2e-3))
            print("min dev check: %.4g %.4g %d" %
                  (lo, row['dev_min'],
                   testutils.check_approx_equal(
                       lo, row['dev_min'], tolerance=2e-3)))
            print("max dev check: %.4g %.4g %d" %
                  (hi, row['dev_max'],
                   testutils.check_approx_equal(
                       hi, row['dev_max'], tolerance=2e-3)))
 def test_mdev_ci(self):
     s32rows = testutils.read_stable32(resultfile='mdev_decade.txt', datarate=1.0)
     for row in s32rows:
         data = testutils.read_datafile(data_file)
         (taus, devs, errs, ns) = allan.mdev(data, rate=rate,
                                               taus=[ row['tau'] ])
         edf = allan.edf_greenhall(alpha=row['alpha'],d=2,m=row['m'],N=len(data),overlapping=True, modified = True, verbose=True)
         (lo,hi) =allan.confidence_intervals(devs[0],ci=0.68268949213708585, edf=edf)
         print("n check: ", testutils.check_equal( ns[0], row['n'] ) )
         print("dev check: ", testutils.check_approx_equal( devs[0], row['dev'] ) )
         print("min dev check: ",  lo, row['dev_min'], testutils.check_approx_equal( lo, row['dev_min'], tolerance=1e-3 ) )
         print("max dev check: ", hi, row['dev_max'], testutils.check_approx_equal( hi, row['dev_max'], tolerance=1e-3 ) )
Exemple #5
0
 def test_mdev_ci(self):
     """ Overlapping ADEV with confidence intervals """
     s32rows = testutils.read_stable32(resultfile='mdev_octave.txt', datarate=1.0)
     for row in s32rows:
         data = testutils.read_datafile(data_file)
         data = allan.frequency2fractional(data, mean_frequency=1.0e7)
         (taus, devs, errs, ns) = allan.mdev(data, rate=rate, data_type="freq",
                                               taus=[ row['tau'] ])
         # NOTE! Here we use alhpa from Stable32-results for the allantools edf computation!
         edf = allan.edf_greenhall(alpha=row['alpha'],d=2,m=row['m'],N=len(data),overlapping=True, modified = True, verbose=True)
         (lo,hi) =allan.confidence_interval(devs[0], edf=edf)
         print("n check: ", testutils.check_equal( ns[0], row['n'] ) )
         print("dev check: ", devs[0], row['dev'], testutils.check_approx_equal( devs[0], row['dev'], tolerance=2e-3 ) )
         print("min dev check: ",  lo, row['dev_min'], testutils.check_approx_equal( lo, row['dev_min'], tolerance=2e-3 ) )
         print("max dev check: ", hi, row['dev_max'], testutils.check_approx_equal( hi, row['dev_max'], tolerance=2e-3 ) )
Exemple #6
0
    def test_totdev_ci(self):
        print("totdev()")
        s32rows = testutils.read_stable32(resultfile='totdev_octave.txt', datarate=1.0)
        for row in s32rows:
            data = testutils.read_datafile(data_file)
            data = allan.frequency2fractional(data, mean_frequency=1.0e7)
            (taus, devs, errs, ns) = allan.totdev(data, rate=rate, data_type="freq",
                                                  taus=[ row['tau'] ])
            edf = allan.edf_totdev(N=len(data),m=row['m'], alpha=row['alpha'])

            (lo,hi) = allan.confidence_interval(devs[0], edf=edf)
            print("n check: ", testutils.check_equal( ns[0], row['n'] ) )
            print("dev check: ", testutils.check_approx_equal( devs[0], row['dev'], tolerance=2e-3 ) )
            print("min dev check: %.4g %.4g %d" %( lo, row['dev_min'], testutils.check_approx_equal( lo, row['dev_min'], tolerance=2e-3 ) ) )
            print("max dev check: %.4g %.4g %d" %( hi, row['dev_max'], testutils.check_approx_equal( hi, row['dev_max'], tolerance=2e-3 ) ) )
Exemple #7
0
 def test_mdev_ci(self):
     s32rows = testutils.read_stable32(resultfile="mdev_octave.txt", datarate=1.0)
     for row in s32rows:
         data = testutils.read_datafile(data_file)
         data = allan.frequency2fractional(data, mean_frequency=1.0e7)
         (taus, devs, errs, ns) = allan.mdev(data, rate=rate, data_type="freq", taus=[row["tau"]])
         edf = allan.edf_greenhall(
             alpha=row["alpha"], d=2, m=row["m"], N=len(data), overlapping=True, modified=True, verbose=True
         )
         (lo, hi) = allan.confidence_intervals(devs[0], ci=0.68268949213708585, edf=edf)
         print("n check: ", testutils.check_equal(ns[0], row["n"]))
         print("dev check: ", devs[0], row["dev"], testutils.check_approx_equal(devs[0], row["dev"], tolerance=2e-3))
         print(
             "min dev check: ", lo, row["dev_min"], testutils.check_approx_equal(lo, row["dev_min"], tolerance=2e-3)
         )
         print(
             "max dev check: ", hi, row["dev_max"], testutils.check_approx_equal(hi, row["dev_max"], tolerance=2e-3)
         )
Exemple #8
0
 def test_adev_ci(self):
     s32rows = testutils.read_stable32(resultfile='adev_decade.txt',
                                       datarate=1.0)
     edfs = []
     err_lo = []
     err_hi = []
     err_dev = []
     for row in s32rows:
         data = testutils.read_datafile(data_file)
         (taus, devs, errs, ns) = allan.adev(data,
                                             rate=rate,
                                             taus=[row['tau']])
         # here allantools does not identify the noise type
         # instead the noise type alpha from Stable 32 is used
         edf = allan.edf_greenhall(alpha=row['alpha'],
                                   d=2,
                                   m=row['m'],
                                   N=len(data),
                                   overlapping=False,
                                   modified=False,
                                   verbose=True)
         (lo, hi) = allan.confidence_interval(devs[0], edf)
         print("n check: ", testutils.check_equal(ns[0], row['n']))
         print("dev check: ",
               testutils.check_approx_equal(devs[0], row['dev']))
         print(
             "min dev check: ", lo, row['dev_min'],
             testutils.check_approx_equal(lo,
                                          row['dev_min'],
                                          tolerance=1e-3))
         print(
             "max dev check: ", hi, row['dev_max'],
             testutils.check_approx_equal(hi,
                                          row['dev_max'],
                                          tolerance=1e-3))
         # store relative errors for later printout
         edfs.append(edf)
         err_dev.append(row['dev'] / devs[0] - 1.0)
         err_hi.append(row['dev_max'] / hi - 1.0)
         err_lo.append(row['dev_min'] / lo - 1.0)
     # print table with relative errors
     for (e, lo, err, hi) in zip(edfs, err_lo, err_dev, err_hi):
         print('%d %.6f %.6f %.6f' % (e, lo, err, hi))