Changes in / [a470e88:ec8886e] in sasview


Ignore:
Files:
19 deleted
3 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/dataloader/manipulations.py

    rfd5d6eac rdd11014  
    55""" 
    66##################################################################### 
    7 # This software was developed by the University of Tennessee as part of the 
    8 # Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    9 # project funded by the US National Science Foundation. 
    10 # See the license text in license.txt 
    11 # copyright 2008, University of Tennessee 
     7#This software was developed by the University of Tennessee as part of the 
     8#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     9#project funded by the US National Science Foundation. 
     10#See the license text in license.txt 
     11#copyright 2008, University of Tennessee 
    1212###################################################################### 
    1313 
    14 # If you want to run just a single test from this file: 
    15 # PYTHONPATH=../src/ python2  -m sasdataloader.test.utest_averaging data_info_tests.test_sectorq_full 
    16 # TODO: copy the meta data from the 2D object to the resulting 1D object 
     14#TODO: copy the meta data from the 2D object to the resulting 1D object 
    1715import math 
    18 import numpy as np 
     16import numpy 
    1917 
    2018#from data_info import plottable_2D 
    … …  
    8482    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None: 
    8583        raise ValueError, "Can't convert this data: data=None..." 
    86     new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
    87     new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
     84    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
     85    new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
    8886    new_y = new_y.swapaxes(0, 1) 
    8987 
    … …  
    9189    qx_data = new_x.flatten() 
    9290    qy_data = new_y.flatten() 
    93     q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    94     if data2d.err_data is None or np.any(data2d.err_data <= 0): 
    95         new_err_data = np.sqrt(np.abs(new_data)) 
     91    q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     92    if data2d.err_data is None or numpy.any(data2d.err_data <= 0): 
     93        new_err_data = numpy.sqrt(numpy.abs(new_data)) 
    9694    else: 
    9795        new_err_data = data2d.err_data.flatten() 
    98     mask = np.ones(len(new_data), dtype=bool) 
    99  
    100     # TODO: make sense of the following two lines... 
     96    mask = numpy.ones(len(new_data), dtype=bool) 
     97 
     98    #TODO: make sense of the following two lines... 
    10199    #from sas.sascalc.dataloader.data_info import Data2D 
    102100    #output = Data2D() 
    … …  
    116114    Compute average I(Q) for a region of interest 
    117115    """ 
    118  
    119116    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, 
    120117                 y_max=0.0, bin_width=0.001): 
    … …  
    152149 
    153150        # Get data 
    154         data = data2D.data[np.isfinite(data2D.data)] 
    155         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    156         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    157         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     151        data = data2D.data[numpy.isfinite(data2D.data)] 
     152        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     153        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     154        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    158155 
    159156        # Build array of Q intervals 
    … …  
    173170            raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj) 
    174171 
    175         x = np.zeros(nbins) 
    176         y = np.zeros(nbins) 
    177         err_y = np.zeros(nbins) 
    178         y_counts = np.zeros(nbins) 
     172        x = numpy.zeros(nbins) 
     173        y = numpy.zeros(nbins) 
     174        err_y = numpy.zeros(nbins) 
     175        y_counts = numpy.zeros(nbins) 
    179176 
    180177        # Average pixelsize in q space 
    … …  
    208205                continue 
    209206 
    210             # TODO: find better definition of x[i_q] based on q_data 
     207            #TODO: find better definition of x[i_q] based on q_data 
    211208            # min_value + (i_q + 1) * self.bin_width / 2.0 
    212209            x[i_q] += frac * q_value 
    213210            y[i_q] += frac * data[npts] 
    214211 
    215             if err_data is None or err_data[npts] == 0.0: 
     212            if err_data == None or err_data[npts] == 0.0: 
    216213                if data[npts] < 0: 
    217214                    data[npts] = -data[npts] 
    … …  
    228225        y = y / y_counts 
    229226        x = x / y_counts 
    230         idx = (np.isfinite(y) & np.isfinite(x)) 
     227        idx = (numpy.isfinite(y) & numpy.isfinite(x)) 
    231228 
    232229        if not idx.any(): 
    … …  
    240237    Compute average I(Qy) for a region of interest 
    241238    """ 
    242  
    243239    def __call__(self, data2D): 
    244240        """ 
    … …  
    255251    Compute average I(Qx) for a region of interest 
    256252    """ 
    257  
    258253    def __call__(self, data2D): 
    259254        """ 
    … …  
    269264    Perform the sum of counts in a 2D region of interest. 
    270265    """ 
    271  
    272266    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0): 
    273267        # Minimum Qx value [A-1] 
    … …  
    310304            raise RuntimeError, msg 
    311305        # Get data 
    312         data = data2D.data[np.isfinite(data2D.data)] 
    313         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    314         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    315         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     306        data = data2D.data[numpy.isfinite(data2D.data)] 
     307        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     308        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     309        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    316310 
    317311        y = 0.0 
    … …  
    334328            if self.y_min <= qy and self.y_max > qy: 
    335329                frac_y = 1 
    336             # Find the fraction along each directions 
     330            #Find the fraction along each directions 
    337331            frac = frac_x * frac_y 
    338332            if frac == 0: 
    339333                continue 
    340334            y += frac * data[npts] 
    341             if err_data is None or err_data[npts] == 0.0: 
     335            if err_data == None or err_data[npts] == 0.0: 
    342336                if data[npts] < 0: 
    343337                    data[npts] = -data[npts] 
    … …  
    353347    Perform the average of counts in a 2D region of interest. 
    354348    """ 
    355  
    356349    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0): 
    357350        super(Boxavg, self).__init__(x_min=x_min, x_max=x_max, 
    … …  
    405398    as a function of Q 
    406399    """ 
    407  
    408400    def __init__(self, r_min=0.0, r_max=0.0, bin_width=0.0005): 
    409401        # Minimum radius included in the average [A-1] 
    … …  
    422414        """ 
    423415        # Get data W/ finite values 
    424         data = data2D.data[np.isfinite(data2D.data)] 
    425         q_data = data2D.q_data[np.isfinite(data2D.data)] 
    426         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    427         mask_data = data2D.mask[np.isfinite(data2D.data)] 
     416        data = data2D.data[numpy.isfinite(data2D.data)] 
     417        q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
     418        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     419        mask_data = data2D.mask[numpy.isfinite(data2D.data)] 
    428420 
    429421        dq_data = None 
    … …  
    456448            dq_overlap_y *= dq_overlap_y 
    457449 
    458             dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     450            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    459451            # Final protection of dq 
    460452            if dq_overlap < 0: 
    461453                dq_overlap = y_min 
    462             dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
    463             dqy_data = data2D.dqy_data[np.isfinite( 
    464                 data2D.data)] - dq_overlap 
     454            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
     455            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
    465456            # def; dqx_data = dq_r dqy_data = dq_phi 
    466457            # Convert dq 2D to 1D here 
    467458            dqx = dqx_data * dqx_data 
    468459            dqy = dqy_data * dqy_data 
    469             dq_data = np.add(dqx, dqy) 
    470             dq_data = np.sqrt(dq_data) 
    471  
    472         #q_data_max = np.max(q_data) 
     460            dq_data = numpy.add(dqx, dqy) 
     461            dq_data = numpy.sqrt(dq_data) 
     462 
     463        #q_data_max = numpy.max(q_data) 
    473464        if len(data2D.q_data) == None: 
    474465            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
    … …  
    478469        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width)) 
    479470 
    480         x = np.zeros(nbins) 
    481         y = np.zeros(nbins) 
    482         err_y = np.zeros(nbins) 
    483         err_x = np.zeros(nbins) 
    484         y_counts = np.zeros(nbins) 
     471        x = numpy.zeros(nbins) 
     472        y = numpy.zeros(nbins) 
     473        err_y = numpy.zeros(nbins) 
     474        err_x = numpy.zeros(nbins) 
     475        y_counts = numpy.zeros(nbins) 
    485476 
    486477        for npt in range(len(data)): 
    … …  
    495486            data_n = data[npt] 
    496487 
    497             # No need to calculate the frac when all data are within range 
     488            ## No need to calculate the frac when all data are within range 
    498489            if self.r_min >= self.r_max: 
    499490                raise ValueError, "Limit Error: min > max" 
    … …  
    511502            # Take dqs from data to get the q_average 
    512503            x[i_q] += frac * q_value 
    513             if err_data is None or err_data[npt] == 0.0: 
     504            if err_data == None or err_data[npt] == 0.0: 
    514505                if data_n < 0: 
    515506                    data_n = -data_n 
    … …  
    532523                err_y[n] = -err_y[n] 
    533524            err_y[n] = math.sqrt(err_y[n]) 
    534             # if err_x != None: 
     525            #if err_x != None: 
    535526            #    err_x[n] = math.sqrt(err_x[n]) 
    536527 
    537528        err_y = err_y / y_counts 
    538         err_y[err_y == 0] = np.average(err_y) 
     529        err_y[err_y == 0] = numpy.average(err_y) 
    539530        y = y / y_counts 
    540531        x = x / y_counts 
    541         idx = (np.isfinite(y)) & (np.isfinite(x)) 
     532        idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
    542533 
    543534        if err_x != None: 
    … …  
    565556    in anti-clockwise starting from the x- axis on the left-hand side 
    566557    """ 
    567     # Todo: remove center. 
    568  
     558    #Todo: remove center. 
    569559    def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0, nbins=36): 
    570560        # Minimum radius 
    … …  
    579569        self.nbins_phi = nbins 
    580570 
     571 
    581572    def __call__(self, data2D): 
    582573        """ 
    … …  
    594585 
    595586        # Get data 
    596         data = data2D.data[np.isfinite(data2D.data)] 
    597         q_data = data2D.q_data[np.isfinite(data2D.data)] 
    598         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    599         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    600         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     587        data = data2D.data[numpy.isfinite(data2D.data)] 
     588        q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
     589        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     590        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     591        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    601592 
    602593        # Set space for 1d outputs 
    603         phi_bins = np.zeros(self.nbins_phi) 
    604         phi_counts = np.zeros(self.nbins_phi) 
    605         phi_values = np.zeros(self.nbins_phi) 
    606         phi_err = np.zeros(self.nbins_phi) 
     594        phi_bins = numpy.zeros(self.nbins_phi) 
     595        phi_counts = numpy.zeros(self.nbins_phi) 
     596        phi_values = numpy.zeros(self.nbins_phi) 
     597        phi_err = numpy.zeros(self.nbins_phi) 
    607598 
    608599        # Shift to apply to calculated phi values in order 
    … …  
    624615                continue 
    625616            # binning 
    626             i_phi = int(math.floor((self.nbins_phi) * 
     617            i_phi = int(math.floor((self.nbins_phi) * \ 
    627618                                   (phi_value + phi_shift) / (2 * Pi))) 
    628619 
    … …  
    632623            phi_bins[i_phi] += frac * data[npt] 
    633624 
    634             if err_data is None or err_data[npt] == 0.0: 
     625            if err_data == None or err_data[npt] == 0.0: 
    635626                if data_n < 0: 
    636627                    data_n = -data_n 
    … …  
    645636            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i) 
    646637 
    647         idx = (np.isfinite(phi_bins)) 
     638        idx = (numpy.isfinite(phi_bins)) 
    648639 
    649640        if not idx.any(): 
    650641            msg = "Average Error: No points inside ROI to average..." 
    651642            raise ValueError, msg 
    652         # elif len(phi_bins[idx])!= self.nbins_phi: 
     643        #elif len(phi_bins[idx])!= self.nbins_phi: 
    653644        #    print "resulted",self.nbins_phi- len(phi_bins[idx]) 
    654645        #,"empty bin(s) due to tight binning..." 
    … …  
    757748    starting from the x- axis on the left-hand side 
    758749    """ 
    759  
    760750    def __init__(self, r_min, r_max, phi_min=0, phi_max=2 * math.pi, nbins=20): 
    761751        self.r_min = r_min 
    … …  
    779769 
    780770        # Get the all data & info 
    781         data = data2D.data[np.isfinite(data2D.data)] 
    782         q_data = data2D.q_data[np.isfinite(data2D.data)] 
    783         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    784         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    785         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     771        data = data2D.data[numpy.isfinite(data2D.data)] 
     772        q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
     773        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     774        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     775        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    786776        dq_data = None 
    787777 
    … …  
    813803            dq_overlap_y *= dq_overlap_y 
    814804 
    815             dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     805            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    816806            if dq_overlap < 0: 
    817807                dq_overlap = y_min 
    818             dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
    819             dqy_data = data2D.dqy_data[np.isfinite( 
    820                 data2D.data)] - dq_overlap 
     808            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
     809            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
    821810            # def; dqx_data = dq_r dqy_data = dq_phi 
    822811            # Convert dq 2D to 1D here 
    823812            dqx = dqx_data * dqx_data 
    824813            dqy = dqy_data * dqy_data 
    825             dq_data = np.add(dqx, dqy) 
    826             dq_data = np.sqrt(dq_data) 
    827  
    828         # set space for 1d outputs 
    829         x = np.zeros(self.nbins) 
    830         y = np.zeros(self.nbins) 
    831         y_err = np.zeros(self.nbins) 
    832         x_err = np.zeros(self.nbins) 
    833         y_counts = np.zeros(self.nbins) 
     814            dq_data = numpy.add(dqx, dqy) 
     815            dq_data = numpy.sqrt(dq_data) 
     816 
     817        #set space for 1d outputs 
     818        x = numpy.zeros(self.nbins) 
     819        y = numpy.zeros(self.nbins) 
     820        y_err = numpy.zeros(self.nbins) 
     821        x_err = numpy.zeros(self.nbins) 
     822        y_counts = numpy.zeros(self.nbins) 
    834823 
    835824        # Get the min and max into the region: 0 <= phi < 2Pi 
    … …  
    850839            phi_value = math.atan2(qy_data[n], qx_data[n]) + Pi 
    851840 
    852             # No need to calculate the frac when all data are within range 
     841            ## No need to calculate the frac when all data are within range 
    853842            if self.r_min <= q_value and q_value <= self.r_max: 
    854843                frac = 1 
    855844            if frac == 0: 
    856845                continue 
    857             # In case of two ROIs (symmetric major and minor regions)(for 'q2') 
     846            #In case of two ROIs (symmetric major and minor regions)(for 'q2') 
    858847            if run.lower() == 'q2': 
    859                 # For minor sector wing 
     848                ## For minor sector wing 
    860849                # Calculate the minor wing phis 
    861850                phi_min_minor = flip_phi(phi_min - Pi) 
    … …  
    863852                # Check if phis of the minor ring is within 0 to 2pi 
    864853                if phi_min_minor > phi_max_minor: 
    865                     is_in = (phi_value > phi_min_minor or 
    866                              phi_value < phi_max_minor) 
     854                    is_in = (phi_value > phi_min_minor or \ 
     855                              phi_value < phi_max_minor) 
    867856                else: 
    868                     is_in = (phi_value > phi_min_minor and 
    869                              phi_value < phi_max_minor) 
    870  
    871             # For all cases(i.e.,for 'q', 'q2', and 'phi') 
    872             # Find pixels within ROI 
     857                    is_in = (phi_value > phi_min_minor and \ 
     858                              phi_value < phi_max_minor) 
     859 
     860            #For all cases(i.e.,for 'q', 'q2', and 'phi') 
     861            #Find pixels within ROI 
    873862            if phi_min > phi_max: 
    874                 is_in = is_in or (phi_value > phi_min or 
    875                                   phi_value < phi_max) 
     863                is_in = is_in or (phi_value > phi_min or \ 
     864                                   phi_value < phi_max) 
    876865            else: 
    877                 is_in = is_in or (phi_value >= phi_min and 
    878                                   phi_value < phi_max) 
     866                is_in = is_in or (phi_value >= phi_min  and \ 
     867                                    phi_value < phi_max) 
    879868 
    880869            if not is_in: 
    … …  
    896885                i_bin = self.nbins - 1 
    897886 
    898             # Get the total y 
     887            ## Get the total y 
    899888            y[i_bin] += frac * data_n 
    900889            x[i_bin] += frac * q_value 
    … …  
    934923                #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2) 
    935924                x[i] = x[i] / y_counts[i] 
    936         y_err[y_err == 0] = np.average(y_err) 
    937         idx = (np.isfinite(y) & np.isfinite(y_err)) 
     925        y_err[y_err == 0] = numpy.average(y_err) 
     926        idx = (numpy.isfinite(y) & numpy.isfinite(y_err)) 
    938927        if x_err != None: 
    939928            d_x = x_err[idx] / y_counts[idx] 
    … …  
    943932            msg = "Average Error: No points inside sector of ROI to average..." 
    944933            raise ValueError, msg 
    945         # elif len(y[idx])!= self.nbins: 
     934        #elif len(y[idx])!= self.nbins: 
    946935        #    print "resulted",self.nbins- len(y[idx]), 
    947936        #"empty bin(s) due to tight binning..." 
    … …  
    957946    The number of bin in phi also has to be defined. 
    958947    """ 
    959  
    960948    def __call__(self, data2D): 
    961949        """ 
    … …  
    977965    The number of bin in Q also has to be defined. 
    978966    """ 
    979  
    980967    def __call__(self, data2D): 
    981968        """ 
    … …  
    1000987    in anti-clockwise starting from the x- axis on the left-hand side 
    1001988    """ 
    1002  
    1003989    def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0): 
    1004990        # Minimum radius 
    … …  
    10261012        qx_data = data2D.qx_data 
    10271013        qy_data = data2D.qy_data 
    1028         q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1014        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10291015 
    10301016        # check whether or not the data point is inside ROI 
    … …  
    10371023    Find a rectangular 2D region of interest. 
    10381024    """ 
    1039  
    10401025    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0): 
    10411026        # Minimum Qx value [A-1] 
    … …  
    10921077    and (phi_max-phi_min) should not be larger than pi 
    10931078    """ 
    1094  
    10951079    def __init__(self, phi_min=0, phi_max=math.pi): 
    10961080        self.phi_min = phi_min 
    … …  
    11291113 
    11301114        # get phi from data 
    1131         phi_data = np.arctan2(qy_data, qx_data) 
     1115        phi_data = numpy.arctan2(qy_data, qx_data) 
    11321116 
    11331117        # Get the min and max into the region: -pi <= phi < Pi 
    … …  
    11361120        # check for major sector 
    11371121        if phi_min_major > phi_max_major: 
    1138             out_major = (phi_min_major <= phi_data) + \ 
    1139                 (phi_max_major > phi_data) 
     1122            out_major = (phi_min_major <= phi_data) + (phi_max_major > phi_data) 
    11401123        else: 
    1141             out_major = (phi_min_major <= phi_data) & ( 
    1142                 phi_max_major > phi_data) 
     1124            out_major = (phi_min_major <= phi_data) & (phi_max_major > phi_data) 
    11431125 
    11441126        # minor sector 
    … …  
    11501132        if phi_min_minor > phi_max_minor: 
    11511133            out_minor = (phi_min_minor <= phi_data) + \ 
    1152                 (phi_max_minor >= phi_data) 
     1134                            (phi_max_minor >= phi_data) 
    11531135        else: 
    11541136            out_minor = (phi_min_minor <= phi_data) & \ 
    1155                 (phi_max_minor >= phi_data) 
     1137                            (phi_max_minor >= phi_data) 
    11561138        out = out_major + out_minor 
    11571139 

  • test/sasdataloader/test/utest_averaging.py

    r4fb10e5 r9a5097c  
    22import unittest 
    33import math 
    4 import os 
    54 
    65from sas.sascalc.dataloader.loader import  Loader 
    … …  
    9897     
    9998    def setUp(self): 
    100         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'MAR07232_rest.ASC') 
    101         self.data = Loader().load(filepath) 
     99        self.data = Loader().load('MAR07232_rest.ASC') 
    102100         
    103101    def test_ring(self): 
    … …  
    112110         
    113111        o = r(self.data) 
    114         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ring_testdata.txt') 
    115         answer = Loader().load(filepath) 
     112        answer = Loader().load('ring_testdata.txt') 
    116113         
    117114        for i in range(r.nbins_phi - 1): 
    … …  
    131128        o = r(self.data) 
    132129 
    133         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'avg_testdata.txt') 
    134         answer = Loader().load(filepath) 
     130        answer = Loader().load('avg_testdata.txt') 
    135131        for i in range(r.nbins_phi): 
    136132            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    167163        o = r(self.data) 
    168164 
    169         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'slabx_testdata.txt') 
    170         answer = Loader().load(filepath) 
     165        answer = Loader().load('slabx_testdata.txt') 
    171166        for i in range(len(o.x)): 
    172167            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    185180        o = r(self.data) 
    186181 
    187         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'slaby_testdata.txt') 
    188         answer = Loader().load(filepath) 
     182        answer = Loader().load('slaby_testdata.txt') 
    189183        for i in range(len(o.x)): 
    190184            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    213207        o = r(self.data) 
    214208 
    215         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ring_testdata.txt') 
    216         answer = Loader().load(filepath) 
     209        answer = Loader().load('ring_testdata.txt') 
    217210        for i in range(len(o.x)): 
    218211            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    232225        o = r(self.data) 
    233226 
    234         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'sectorphi_testdata.txt') 
    235         answer = Loader().load(filepath) 
     227        answer = Loader().load('sectorphi_testdata.txt') 
    236228        for i in range(len(o.x)): 
    237229            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    251243        o = r(self.data) 
    252244 
    253         filepath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'sectorq_testdata.txt') 
    254         answer = Loader().load(filepath) 
     245        answer = Loader().load('sectorq_testdata.txt') 
    255246        for i in range(len(o.x)): 
    256247            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 

  • test/sasguiframe/test/utest_manipulations.py

    rfd5d6eac r9a5097c  
    22    Unit tests for data manipulations 
    33""" 
    4 # TODO: what happens if you add a Data1D to a Data2D? 
    5  
     4#TODO: what happens if you add a Data1D to a Data2D? 
     5 
     6import unittest 
    67import math 
     8import numpy as np 
     9from sas.sascalc.dataloader.loader import  Loader 
     10from sas.sasgui.guiframe.dataFitting import Data1D, Data2D 
     11from sas.sasgui.guiframe.dataFitting import Data1D as Theory1D 
     12  
    713import os.path 
    8 import unittest 
    9  
    10 import numpy as np 
    11  
    12 from sas.sascalc.dataloader.loader import Loader 
    13 from sas.sasgui.guiframe.dataFitting import Data1D as Theory1D 
    14 from sas.sasgui.guiframe.dataFitting import Data2D 
    15  
    1614 
    1715class data_info_tests(unittest.TestCase): 
    18  
     16     
    1917    def setUp(self): 
    2018        data = Loader().load("cansas1d.xml") 
    2119        self.data = data[0] 
    22  
     20         
    2321    def test_clone1D(self): 
    2422        """ 
    … …  
    2624        """ 
    2725        clone = self.data.clone_without_data() 
    28  
     26         
    2927        for i in range(len(self.data.detector)): 
    30             self.assertEqual( 
    31                 self.data.detector[i].distance, clone.detector[i].distance) 
    32  
    33  
     28            self.assertEqual(self.data.detector[i].distance, clone.detector[i].distance) 
     29             
    3430class theory1d_tests(unittest.TestCase): 
    35  
     31     
    3632    def setUp(self): 
    3733        data = Loader().load("cansas1d.xml") 
    3834        self.data = data[0] 
    39  
     35         
    4036    def test_clone_theory1D(self): 
    4137        """ 
    … …  
    4642        theory.copy_from_datainfo(data1d=self.data) 
    4743        for i in range(len(self.data.detector)): 
    48             self.assertEqual( 
    49                 self.data.detector[i].distance, theory.detector[i].distance) 
    50  
     44            self.assertEqual(self.data.detector[i].distance, theory.detector[i].distance) 
     45             
    5146        for i in range(len(self.data.x)): 
    5247            self.assertEqual(self.data.x[i], theory.x[i]) 
    … …  
    5449            self.assertEqual(self.data.dy[i], theory.dy[i]) 
    5550 
    56  
    5751class manip_tests(unittest.TestCase): 
    58  
     52     
    5953    def setUp(self): 
    6054        # Create two data sets to play with 
    6155        x_0 = np.ones(5) 
    6256        for i in range(5): 
    63             x_0[i] = x_0[i] * (i + 1.0) 
    64  
    65         y_0 = 2.0 * np.ones(5) 
    66         dy_0 = 0.5 * np.ones(5) 
     57            x_0[i] = x_0[i]*(i+1.0) 
     58             
     59        y_0 = 2.0*np.ones(5) 
     60        dy_0 = 0.5*np.ones(5) 
    6761        self.data = Data1D(x_0, y_0, dy=dy_0) 
    68  
     62         
    6963        x = self.data.x 
    7064        y = np.ones(5) 
    7165        dy = np.ones(5) 
    7266        self.data2 = Data1D(x, y, dy=dy) 
    73  
     67         
     68         
    7469    def test_load(self): 
    7570        """ 
    … …  
    7873        # There should be 5 entries in the file 
    7974        self.assertEqual(len(self.data.x), 5) 
    80  
     75         
    8176        for i in range(5): 
    8277            # The x values should be from 1 to 5 
    83             self.assertEqual(self.data.x[i], float(i + 1)) 
    84  
     78            self.assertEqual(self.data.x[i], float(i+1)) 
     79         
    8580            # All y-error values should be 0.5 
    86             self.assertEqual(self.data.dy[i], 0.5) 
    87  
     81            self.assertEqual(self.data.dy[i], 0.5)     
     82             
    8883            # All y values should be 2.0 
    89             self.assertEqual(self.data.y[i], 2.0) 
    90  
     84            self.assertEqual(self.data.y[i], 2.0)     
     85         
    9186    def test_add(self): 
    92         result = self.data2 + self.data 
     87        result = self.data2+self.data 
    9388        for i in range(5): 
    9489            self.assertEqual(result.y[i], 3.0) 
    95             self.assertEqual(result.dy[i], math.sqrt(0.5**2 + 1.0)) 
    96  
     90            self.assertEqual(result.dy[i], math.sqrt(0.5**2+1.0)) 
     91         
    9792    def test_sub(self): 
    98         result = self.data2 - self.data 
     93        result = self.data2-self.data 
    9994        for i in range(5): 
    10095            self.assertEqual(result.y[i], -1.0) 
    101             self.assertEqual(result.dy[i], math.sqrt(0.5**2 + 1.0)) 
    102  
     96            self.assertEqual(result.dy[i], math.sqrt(0.5**2+1.0)) 
     97         
    10398    def test_mul(self): 
    104         result = self.data2 * self.data 
     99        result = self.data2*self.data 
    105100        for i in range(5): 
    106101            self.assertEqual(result.y[i], 2.0) 
    107             self.assertEqual(result.dy[i], math.sqrt( 
    108                 (0.5 * 1.0)**2 + (1.0 * 2.0)**2)) 
    109  
     102            self.assertEqual(result.dy[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2)) 
     103         
    110104    def test_div(self): 
    111         result = self.data2 / self.data 
     105        result = self.data2/self.data 
    112106        for i in range(5): 
    113107            self.assertEqual(result.y[i], 0.5) 
    114             self.assertEqual(result.dy[i], math.sqrt( 
    115                 (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2)) 
    116  
     108            self.assertEqual(result.dy[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2)) 
     109         
    117110    def test_radd(self): 
    118         result = self.data + 3.0 
     111        result = self.data+3.0 
    119112        for i in range(5): 
    120113            self.assertEqual(result.y[i], 5.0) 
    121114            self.assertEqual(result.dy[i], 0.5) 
    122  
    123         result = 3.0 + self.data 
     115             
     116        result = 3.0+self.data 
    124117        for i in range(5): 
    125118            self.assertEqual(result.y[i], 5.0) 
    126119            self.assertEqual(result.dy[i], 0.5) 
    127  
     120             
    128121    def test_rsub(self): 
    129         result = self.data - 3.0 
     122        result = self.data-3.0 
    130123        for i in range(5): 
    131124            self.assertEqual(result.y[i], -1.0) 
    132125            self.assertEqual(result.dy[i], 0.5) 
    133  
    134         result = 3.0 - self.data 
     126             
     127        result = 3.0-self.data 
    135128        for i in range(5): 
    136129            self.assertEqual(result.y[i], 1.0) 
    137130            self.assertEqual(result.dy[i], 0.5) 
    138  
     131             
    139132    def test_rmul(self): 
    140         result = self.data * 3.0 
     133        result = self.data*3.0 
    141134        for i in range(5): 
    142135            self.assertEqual(result.y[i], 6.0) 
    143136            self.assertEqual(result.dy[i], 1.5) 
    144  
    145         result = 3.0 * self.data 
     137             
     138        result = 3.0*self.data 
    146139        for i in range(5): 
    147140            self.assertEqual(result.y[i], 6.0) 
    148141            self.assertEqual(result.dy[i], 1.5) 
    149  
     142             
    150143    def test_rdiv(self): 
    151         result = self.data / 4.0 
     144        result = self.data/4.0 
    152145        for i in range(5): 
    153146            self.assertEqual(result.y[i], 0.5) 
    154147            self.assertEqual(result.dy[i], 0.125) 
    155  
    156         result = 6.0 / self.data 
     148             
     149        result = 6.0/self.data 
    157150        for i in range(5): 
    158151            self.assertEqual(result.y[i], 3.0) 
    159             self.assertEqual(result.dy[i], 6.0 * 0.5 / 4.0) 
    160  
    161  
     152            self.assertEqual(result.dy[i], 6.0*0.5/4.0) 
     153             
    162154class manip_2D(unittest.TestCase): 
    163  
     155     
    164156    def setUp(self): 
    165157        # Create two data sets to play with 
    166         x_0 = 2.0 * np.ones(25) 
    167         dx_0 = 0.5 * np.ones(25) 
     158        x_0 = 2.0*np.ones(25) 
     159        dx_0 = 0.5*np.ones(25) 
    168160        qx_0 = np.arange(25) 
    169161        qy_0 = np.arange(25) 
    170162        mask_0 = np.zeros(25) 
    171         dqx_0 = np.arange(25) / 100 
    172         dqy_0 = np.arange(25) / 100 
     163        dqx_0 = np.arange(25)/100 
     164        dqy_0 = np.arange(25)/100 
    173165        q_0 = np.sqrt(qx_0 * qx_0 + qy_0 * qy_0) 
    174         self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0, 
    175                            qy_data=qy_0, q_data=q_0, mask=mask_0, 
     166        self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,  
     167                           qy_data=qy_0, q_data=q_0, mask=mask_0,  
    176168                           dqx_data=dqx_0, dqy_data=dqy_0) 
    177  
     169         
    178170        y = np.ones(25) 
    179171        dy = np.ones(25) 
    … …  
    182174        mask = np.zeros(25) 
    183175        q = np.sqrt(qx * qx + qy * qy) 
    184         self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy, 
     176        self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,  
    185177                            q_data=q, mask=mask) 
    186  
     178         
     179         
    187180    def test_load(self): 
    188181        """ 
    … …  
    191184        # There should be 5 entries in the file 
    192185        self.assertEqual(np.size(self.data.data), 25) 
    193  
     186         
    194187        for i in range(25): 
    195188            # All y-error values should be 0.5 
    196             self.assertEqual(self.data.err_data[i], 0.5) 
    197  
     189            self.assertEqual(self.data.err_data[i], 0.5)     
     190             
    198191            # All y values should be 2.0 
    199             self.assertEqual(self.data.data[i], 2.0) 
    200  
     192            self.assertEqual(self.data.data[i], 2.0)     
     193         
    201194    def test_add(self): 
    202         result = self.data2 + self.data 
     195        result = self.data2+self.data 
    203196        for i in range(25): 
    204197            self.assertEqual(result.data[i], 3.0) 
    205             self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
    206  
     198            self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
     199         
    207200    def test_sub(self): 
    208         result = self.data2 - self.data 
     201        result = self.data2-self.data 
     202        for i in range(25): 
     203                self.assertEqual(result.data[i], -1.0) 
     204                self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
     205         
     206    def test_mul(self): 
     207        result = self.data2*self.data 
     208        for i in range(25): 
     209            self.assertEqual(result.data[i], 2.0) 
     210            self.assertEqual(result.err_data[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2)) 
     211         
     212    def test_div(self): 
     213        result = self.data2/self.data 
     214        for i in range(25): 
     215            self.assertEqual(result.data[i], 0.5) 
     216            self.assertEqual(result.err_data[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2)) 
     217         
     218    def test_radd(self): 
     219        result = self.data+3.0 
     220        for i in range(25): 
     221            self.assertEqual(result.data[i], 5.0) 
     222            self.assertEqual(result.err_data[i], 0.5) 
     223    
     224        result = 3.0+self.data 
     225        for i in range(25): 
     226            self.assertEqual(result.data[i], 5.0) 
     227            self.assertEqual(result.err_data[i], 0.5) 
     228             
     229    def test_rsub(self): 
     230        result = self.data-3.0 
    209231        for i in range(25): 
    210232            self.assertEqual(result.data[i], -1.0) 
    211             self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
    212  
    213     def test_mul(self): 
    214         result = self.data2 * self.data 
    215         for i in range(25): 
    216             self.assertEqual(result.data[i], 2.0) 
    217             self.assertEqual(result.err_data[i], math.sqrt( 
    218                 (0.5 * 1.0)**2 + (1.0 * 2.0)**2)) 
    219  
    220     def test_div(self): 
    221         result = self.data2 / self.data 
    222         for i in range(25): 
    223             self.assertEqual(result.data[i], 0.5) 
    224             self.assertEqual(result.err_data[i], math.sqrt( 
    225                 (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2)) 
    226  
    227     def test_radd(self): 
    228         result = self.data + 3.0 
    229         for i in range(25): 
    230             self.assertEqual(result.data[i], 5.0) 
    231             self.assertEqual(result.err_data[i], 0.5) 
    232  
    233         result = 3.0 + self.data 
    234         for i in range(25): 
    235             self.assertEqual(result.data[i], 5.0) 
    236             self.assertEqual(result.err_data[i], 0.5) 
    237  
    238     def test_rsub(self): 
    239         result = self.data - 3.0 
    240         for i in range(25): 
    241             self.assertEqual(result.data[i], -1.0) 
    242             self.assertEqual(result.err_data[i], 0.5) 
    243  
    244         result = 3.0 - self.data 
     233            self.assertEqual(result.err_data[i], 0.5) 
     234     
     235        result = 3.0-self.data 
    245236        for i in range(25): 
    246237            self.assertEqual(result.data[i], 1.0) 
    247238            self.assertEqual(result.err_data[i], 0.5) 
    248  
     239             
    249240    def test_rmul(self): 
    250         result = self.data * 3.0 
     241        result = self.data*3.0 
    251242        for i in range(25): 
    252243            self.assertEqual(result.data[i], 6.0) 
    253244            self.assertEqual(result.err_data[i], 1.5) 
    254  
    255         result = 3.0 * self.data 
     245  
     246        result = 3.0*self.data 
    256247        for i in range(25): 
    257248            self.assertEqual(result.data[i], 6.0) 
    258249            self.assertEqual(result.err_data[i], 1.5) 
    259  
     250             
    260251    def test_rdiv(self): 
    261         result = self.data / 4.0 
     252        result = self.data/4.0 
    262253        for i in range(25): 
    263254            self.assertEqual(result.data[i], 0.5) 
    264255            self.assertEqual(result.err_data[i], 0.125) 
    265256 
    266         result = 6.0 / self.data 
     257        result = 6.0/self.data 
    267258        for i in range(25): 
    268259            self.assertEqual(result.data[i], 3.0) 
    269             self.assertEqual(result.err_data[i], 6.0 * 0.5 / 4.0) 
    270  
    271  
     260            self.assertEqual(result.err_data[i], 6.0*0.5/4.0) 
     261     
    272262class extra_manip_2D(unittest.TestCase): 
    273  
     263     
    274264    def setUp(self): 
    275265        # Create two data sets to play with 
    276         x_0 = 2.0 * np.ones(25) 
    277         dx_0 = 0.5 * np.ones(25) 
     266        x_0 = 2.0*np.ones(25) 
     267        dx_0 = 0.5*np.ones(25) 
    278268        qx_0 = np.arange(25) 
    279269        qy_0 = np.arange(25) 
    280270        mask_0 = np.zeros(25) 
    281         dqx_0 = np.arange(25) / 100 
    282         dqy_0 = np.arange(25) / 100 
     271        dqx_0 = np.arange(25)/100 
     272        dqy_0 = np.arange(25)/100 
    283273        q_0 = np.sqrt(qx_0 * qx_0 + qy_0 * qy_0) 
    284         self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0, 
    285                            qy_data=qy_0, q_data=q_0, mask=mask_0, 
     274        self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,  
     275                           qy_data=qy_0, q_data=q_0, mask=mask_0,  
    286276                           dqx_data=dqx_0, dqy_data=dqy_0) 
    287  
     277         
    288278        y = np.ones(25) 
    289279        dy = np.ones(25) 
    … …  
    292282        mask = np.zeros(25) 
    293283        q = np.sqrt(qx * qx + qy * qy) 
    294         self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy, 
     284        self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,  
    295285                            q_data=q, mask=mask) 
    296  
     286         
     287         
    297288    def test_load(self): 
    298289        """ 
    … …  
    301292        # There should be 5 entries in the file 
    302293        self.assertEqual(np.size(self.data.data), 25) 
    303  
     294         
    304295        for i in range(25): 
    305296            # All y-error values should be 0.5 
    306             self.assertEqual(self.data.err_data[i], 0.5) 
    307  
     297            self.assertEqual(self.data.err_data[i], 0.5)     
     298             
    308299            # All y values should be 2.0 
    309             self.assertEqual(self.data.data[i], 2.0) 
    310  
     300            self.assertEqual(self.data.data[i], 2.0)     
     301         
    311302    def test_add(self): 
    312         result = self.data2 + self.data 
     303        result = self.data2+self.data 
    313304        for i in range(25): 
    314305            self.assertEqual(result.data[i], 3.0) 
    315             self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
    316  
     306            self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
     307         
    317308    def test_sub(self): 
    318         result = self.data2 - self.data 
     309        result = self.data2-self.data 
     310        for i in range(25): 
     311                self.assertEqual(result.data[i], -1.0) 
     312                self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
     313         
     314    def test_mul(self): 
     315        result = self.data2*self.data 
     316        for i in range(25): 
     317            self.assertEqual(result.data[i], 2.0) 
     318            self.assertEqual(result.err_data[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2)) 
     319         
     320    def test_div(self): 
     321        result = self.data2/self.data 
     322        for i in range(25): 
     323            self.assertEqual(result.data[i], 0.5) 
     324            self.assertEqual(result.err_data[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2)) 
     325         
     326    def test_radd(self): 
     327        result = self.data+3.0 
     328        for i in range(25): 
     329            self.assertEqual(result.data[i], 5.0) 
     330            self.assertEqual(result.err_data[i], 0.5) 
     331    
     332        result = 3.0+self.data 
     333        for i in range(25): 
     334            self.assertEqual(result.data[i], 5.0) 
     335            self.assertEqual(result.err_data[i], 0.5) 
     336             
     337    def test_rsub(self): 
     338        result = self.data-3.0 
    319339        for i in range(25): 
    320340            self.assertEqual(result.data[i], -1.0) 
    321             self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
    322  
    323     def test_mul(self): 
    324         result = self.data2 * self.data 
    325         for i in range(25): 
    326             self.assertEqual(result.data[i], 2.0) 
    327             self.assertEqual(result.err_data[i], math.sqrt( 
    328                 (0.5 * 1.0)**2 + (1.0 * 2.0)**2)) 
    329  
    330     def test_div(self): 
    331         result = self.data2 / self.data 
    332         for i in range(25): 
    333             self.assertEqual(result.data[i], 0.5) 
    334             self.assertEqual(result.err_data[i], math.sqrt( 
    335                 (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2)) 
    336  
    337     def test_radd(self): 
    338         result = self.data + 3.0 
    339         for i in range(25): 
    340             self.assertEqual(result.data[i], 5.0) 
    341             self.assertEqual(result.err_data[i], 0.5) 
    342  
    343         result = 3.0 + self.data 
    344         for i in range(25): 
    345             self.assertEqual(result.data[i], 5.0) 
    346             self.assertEqual(result.err_data[i], 0.5) 
    347  
    348     def test_rsub(self): 
    349         result = self.data - 3.0 
    350         for i in range(25): 
    351             self.assertEqual(result.data[i], -1.0) 
    352             self.assertEqual(result.err_data[i], 0.5) 
    353  
    354         result = 3.0 - self.data 
     341            self.assertEqual(result.err_data[i], 0.5) 
     342     
     343        result = 3.0-self.data 
    355344        for i in range(25): 
    356345            self.assertEqual(result.data[i], 1.0) 
    357346            self.assertEqual(result.err_data[i], 0.5) 
    358  
     347             
    359348    def test_rmul(self): 
    360         result = self.data * 3.0 
     349        result = self.data*3.0 
    361350        for i in range(25): 
    362351            self.assertEqual(result.data[i], 6.0) 
    363352            self.assertEqual(result.err_data[i], 1.5) 
    364  
    365         result = 3.0 * self.data 
     353  
     354        result = 3.0*self.data 
    366355        for i in range(25): 
    367356            self.assertEqual(result.data[i], 6.0) 
    368357            self.assertEqual(result.err_data[i], 1.5) 
    369  
     358             
    370359    def test_rdiv(self): 
    371         result = self.data / 4.0 
     360        result = self.data/4.0 
    372361        for i in range(25): 
    373362            self.assertEqual(result.data[i], 0.5) 
    374363            self.assertEqual(result.err_data[i], 0.125) 
    375364 
    376         result = 6.0 / self.data 
     365        result = 6.0/self.data 
    377366        for i in range(25): 
    378367            self.assertEqual(result.data[i], 3.0) 
    379             self.assertEqual(result.err_data[i], 6.0 * 0.5 / 4.0) 
    380  
     368            self.assertEqual(result.err_data[i], 6.0*0.5/4.0) 
    381369 
    382370if __name__ == '__main__': 
    383371    unittest.main() 
     372    
Note: See TracChangeset for help on using the changeset viewer.