Changeset 9923:5f55c90e0077 in orange


Ignore:
Timestamp:
02/07/12 13:46:21 (2 years ago)
Author:
markotoplak
Branch:
default
Message:

data.variable -> feature.

Location:
Orange
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • Orange/classification/logreg.py

    r9919 r9923  
    4646    :type domain: :class:`Orange.data.Domain` 
    4747    """ 
    48     return any(at.var_type == Orange.data.Type.Discrete 
     48    return any(at.var_type == Orange.feature.Type.Discrete 
    4949               for at in domain.features) 
    5050 
     
    215215                # za vsak atribut kreiraj nov newExampleTable new_data 
    216216                # v dataOrig, dataFinal in new_data dodaj nov atribut -- continuous variable 
    217                 if at.var_type == Orange.data.Type.Continuous: 
     217                if at.var_type == Orange.feature.Type.Continuous: 
    218218                    at_disc = Orange.feature.Continuous(at.name+ "Disc") 
    219219                    new_domain = Orange.data.Domain(data.domain.features+[at_disc,data.domain.class_var]) 
     
    228228                        d[at] = 0 
    229229                        d[weight_id] = 0.000001*data[i][weight_id] 
    230                 elif at.var_type == Orange.data.Type.Discrete: 
     230                elif at.var_type == Orange.feature.Type.Discrete: 
    231231                # v dataOrig, dataFinal in new_data atributu "at" dodaj ee  eno  vreednost, ki ima vrednost kar  ime atributa +  "X" 
    232232                    at_new = Orange.feature.Discrete(at.name, values = at.values + [at.name+"X"]) 
     
    335335                # za vsak atribut kreiraj nov newExampleTable newData 
    336336                # v dataOrig, dataFinal in newData dodaj nov atribut -- continuous variable 
    337                 if at.var_type == Orange.data.Type.Continuous: 
     337                if at.var_type == Orange.feature.Type.Continuous: 
    338338                    atDisc = Orange.feature.Continuous(at.name + "Disc") 
    339339                    newDomain = Orange.data.Domain(orig_data.domain.features+[atDisc,data.domain.class_var]) 
     
    351351                        d[weightID] = 100*data[i][weightID] 
    352352                         
    353                 elif at.var_type == Orange.data.Type.Discrete: 
     353                elif at.var_type == Orange.feature.Type.Discrete: 
    354354                # v dataOrig, dataFinal in newData atributu "at" dodaj ee  eno  vreednost, ki ima vrednost kar  ime atributa +  "X" 
    355355                    at_new = Orange.feature.Discrete(at.name, values = at.values + [at.name+"X"]) 
     
    455455        for i in range(len(data.domain.features)): 
    456456          a = data.domain.features[i] 
    457           if a.var_type == Orange.data.Type.Discrete: 
     457          if a.var_type == Orange.feature.Type.Discrete: 
    458458            for m in ml: 
    459459              m[i] = a.values.index(m[i]) 
     
    546546        ml = data.native(0) 
    547547        for i,a in enumerate(data.domain.features): 
    548           if a.var_type == Orange.data.Type.Discrete: 
     548          if a.var_type == Orange.feature.Type.Discrete: 
    549549            for m in ml: 
    550550              m[i] = a.values.index(m[i]) 
     
    802802            # deletion of attribute 
    803803 
    804             if worstAt.var_type==Orange.data.Type.Continuous: 
     804            if worstAt.var_type==Orange.feature.Type.Continuous: 
    805805                P=lchisqprob(minG,1); 
    806806            else: 
     
    850850            continue 
    851851 
    852         if bestAt.var_type==Orange.data.Type.Continuous: 
     852        if bestAt.var_type==Orange.feature.Type.Continuous: 
    853853            P=lchisqprob(maxG,1); 
    854854        else: 
  • Orange/classification/svm/__init__.py

    r9919 r9923  
    649649                SVs[sv_ind].getmetas(False, Orange.feature.Descriptor).keys() 
    650650                for attr in attributes: 
    651                     if attr.varType == Orange.data.Type.Continuous: 
     651                    if attr.varType == Orange.feature.Type.Continuous: 
    652652                        update_weights(w, attr, to_float(SVs[sv_ind][attr]), \ 
    653653                                       classifier.coef[coef_ind][sv_ind]) 
     
    657657                SVs[sv_ind].getmetas(False, Orange.feature.Descriptor).keys() 
    658658                for attr in attributes: 
    659                     if attr.varType==Orange.data.Type.Continuous: 
     659                    if attr.varType==Orange.feature.Type.Continuous: 
    660660                        update_weights(w, attr, to_float(SVs[sv_ind][attr]), \ 
    661661                                       classifier.coef[coef_ind][sv_ind]) 
     
    826826    attrs = data.domain.attributes + data.domain.getmetas().values() 
    827827    attrs = [attr for attr in attrs if attr.varType  
    828              in [Orange.data.Type.Continuous,  
    829                  Orange.data.Type.Discrete]] 
     828             in [Orange.feature.Type.Continuous,  
     829                 Orange.feature.Type.Discrete]] 
    830830    cv = data.domain.classVar 
    831831     
    832832    for ex in data: 
    833         if cv.varType == Orange.data.Type.Discrete: 
     833        if cv.varType == Orange.feature.Type.Discrete: 
    834834            file.write(str(int(ex[cv])))   
    835835        else: 
  • Orange/classification/tree.py

    r9919 r9923  
    18491849        if not self._handset_split and not self.measure: 
    18501850            measure = fscoring.GainRatio() \ 
    1851                 if instances.domain.class_var.var_type == Orange.data.Type.Discrete \ 
     1851                if instances.domain.class_var.var_type == Orange.feature.Type.Discrete \ 
    18521852                else fscoring.MSE() 
    18531853            bl.split.continuous_split_constructor.measure = measure 
     
    21262126 
    21272127def replaceCdisc(strg, mo, node, parent, tree): 
    2128     if tree.class_var.var_type != Orange.data.Type.Discrete: 
     2128    if tree.class_var.var_type != Orange.feature.Type.Discrete: 
    21292129        return insert_dot(strg, mo) 
    21302130 
     
    21442144 
    21452145def replacecdisc(strg, mo, node, parent, tree): 
    2146     if tree.class_var.var_type != Orange.data.Type.Discrete: 
     2146    if tree.class_var.var_type != Orange.feature.Type.Discrete: 
    21472147        return insert_dot(strg, mo) 
    21482148 
     
    21662166 
    21672167def replaceCcont(strg, mo, node, parent, tree): 
    2168     if tree.class_var.var_type != Orange.data.Type.Continuous: 
     2168    if tree.class_var.var_type != Orange.feature.Type.Continuous: 
    21692169        return insert_dot(strg, mo) 
    21702170 
     
    21862186 
    21872187def replaceccont(strg, mo, node, parent, tree): 
    2188     if tree.class_var.var_type != Orange.data.Type.Continuous: 
     2188    if tree.class_var.var_type != Orange.feature.Type.Continuous: 
    21892189        return insert_dot(strg, mo) 
    21902190 
     
    22202220 
    22212221def replaceCconti(strg, mo, node, parent, tree): 
    2222     if tree.class_var.var_type != Orange.data.Type.Continuous: 
     2222    if tree.class_var.var_type != Orange.feature.Type.Continuous: 
    22232223        return insert_dot(strg, mo) 
    22242224 
     
    22382238 
    22392239def replacecconti(strg, mo, node, parent, tree): 
    2240     if tree.class_var.var_type != Orange.data.Type.Continuous: 
     2240    if tree.class_var.var_type != Orange.feature.Type.Continuous: 
    22412241        return insert_dot(strg, mo) 
    22422242 
     
    22602260 
    22612261def replaceD(strg, mo, node, parent, tree): 
    2262     if tree.class_var.var_type != Orange.data.Type.Discrete: 
     2262    if tree.class_var.var_type != Orange.feature.Type.Discrete: 
    22632263        return insert_dot(strg, mo) 
    22642264 
     
    22792279 
    22802280def replaced(strg, mo, node, parent, tree): 
    2281     if tree.class_var.var_type != Orange.data.Type.Discrete: 
     2281    if tree.class_var.var_type != Orange.feature.Type.Discrete: 
    22822282        return insert_dot(strg, mo) 
    22832283 
     
    23012301 
    23022302def replaceAE(strg, mo, node, parent, tree): 
    2303     if tree.class_var.var_type != Orange.data.Type.Continuous: 
     2303    if tree.class_var.var_type != Orange.feature.Type.Continuous: 
    23042304        return insert_dot(strg, mo) 
    23052305 
     
    23302330 
    23312331def replaceI(strg, mo, node, parent, tree): 
    2332     if tree.class_var.var_type != Orange.data.Type.Continuous: 
     2332    if tree.class_var.var_type != Orange.feature.Type.Continuous: 
    23332333        return insert_dot(strg, mo) 
    23342334 
     
    23732373        else: 
    23742374            if self.node().node_classifier.class_var.var_type == \ 
    2375                     Orange.data.Type.Discrete: 
     2375                    Orange.feature.Type.Discrete: 
    23762376                self.leafStr = "%V (%^.2m%)" 
    23772377            else: 
     
    26572657    def to_network(self): 
    26582658        net = Orange.network.DiGraph() 
    2659         if self.class_var.var_type == Orange.data.Type.Discrete: 
     2659        if self.class_var.var_type == Orange.feature.Type.Discrete: 
    26602660            domain = Orange.data.Domain([self.class_var] + 
    26612661                [Orange.feature.Continuous(name) for name in 
     
    26762676        d = node.distribution 
    26772677        maj = node.node_classifier.default_value 
    2678         if self.class_var.var_type == Orange.data.Type.Discrete: 
     2678        if self.class_var.var_type == Orange.feature.Type.Discrete: 
    26792679            if d.abs > 1e-6: 
    26802680                table.append([maj, d.abs, d[maj]] + [x / d.abs for x in d]) 
  • Orange/data/io.py

    r9919 r9923  
    191191                        if len(sy) > 0: 
    192192                            vals.append(sy) 
    193                     a, s = make(atn, Orange.data.Type.Discrete, vals, [], create_on_new) 
     193                    a, s = make(atn, Orange.feature.Type.Discrete, vals, [], create_on_new) 
    194194                else: 
    195195                    # real... 
    196                     a, s = make(atn, Orange.data.Type.Continuous, [], [], create_on_new) 
     196                    a, s = make(atn, Orange.feature.Type.Continuous, [], [], create_on_new) 
    197197 
    198198                attributes.append(a) 
     
    399399    attributeLoadStatus = {} 
    400400    def make_float(name): 
    401         attr, s = Orange.feature.Descriptor.make(name, Orange.data.Type.Continuous, [], [], create_on_new) 
     401        attr, s = Orange.feature.Descriptor.make(name, Orange.feature.Type.Continuous, [], [], create_on_new) 
    402402        attributeLoadStatus[attr] = s 
    403403        return attr 
    404404 
    405405    def make_disc(name, unordered): 
    406         attr, s = Orange.feature.Descriptor.make(name, Orange.data.Type.Discrete, [], unordered, create_on_new) 
     406        attr, s = Orange.feature.Descriptor.make(name, Orange.feature.Type.Discrete, [], unordered, create_on_new) 
    407407        attributeLoadStatus[attr] = s 
    408408        return attr 
     
    633633            undefined_vars.append((i, variables[-1])) 
    634634        elif var_t == variable.Continuous: 
    635             variables.append(variable.make(name, Orange.data.Type.Continuous, [], [], create_new_on)) 
     635            variables.append(variable.make(name, Orange.feature.Type.Continuous, [], [], create_new_on)) 
    636636        elif var_t == variable.String: 
    637             variables.append(variable.make(name, Orange.data.Type.String, [], [], create_new_on)) 
     637            variables.append(variable.make(name, Orange.feature.Type.String, [], [], create_new_on)) 
    638638        elif var_t == variable.Python: 
    639639            variables.append(variable.Python(name)) 
     
    641641            var_t, values = var_t 
    642642            if var_t == variable.Discrete: 
    643                 variables.append(variable.make(name, Orange.data.Type.Discrete, values, [], create_new_on)) 
     643                variables.append(variable.make(name, Orange.feature.Type.Discrete, values, [], create_new_on)) 
    644644            elif var_t == variable.Python: 
    645645                raise NotImplementedError() 
     
    658658        values = sorted(values) 
    659659        if isinstance(var_def, _disc_placeholder): 
    660             variables[ind] = variable.make(var_def.name, Orange.data.Type.Discrete, [], values, create_new_on) 
     660            variables[ind] = variable.make(var_def.name, Orange.feature.Type.Discrete, [], values, create_new_on) 
    661661        elif isinstance(var_def, _var_placeholder): 
    662662            if is_variable_cont(values): 
    663                 variables[ind] = variable.make(var_def.name, Orange.data.Type.Continuous, [], [], create_new_on) 
     663                variables[ind] = variable.make(var_def.name, Orange.feature.Type.Continuous, [], [], create_new_on) 
    664664            elif is_variable_discrete(values): 
    665                 variables[ind] = variable.make(var_def.name, Orange.data.Type.Discrete, [], values, create_new_on) 
     665                variables[ind] = variable.make(var_def.name, Orange.feature.Type.Discrete, [], values, create_new_on) 
    666666            elif is_variable_string(values): 
    667                 variables[ind] = variable.make(var_def.name, Orange.data.Type.String, [], [], create_new_on) 
     667                variables[ind] = variable.make(var_def.name, Orange.feature.Type.String, [], [], create_new_on) 
    668668            else: 
    669669                raise ValueError("Strange column in the data") 
  • Orange/distance/__init__.py

    r9916 r9923  
    3838    def __call__(self, table): 
    3939        indxs = [i for i, a in enumerate(table.domain.attributes) \ 
    40                  if a.varType==Orange.data.Type.Continuous] 
     40                 if a.varType==Orange.feature.Type.Continuous] 
    4141        return PearsonRDistance(domain=table.domain, indxs=indxs) 
    4242 
     
    8484    def __call__(self, table): 
    8585        indxs = [i for i, a in enumerate(table.domain.attributes) \ 
    86                  if a.varType==Orange.data.Type.Continuous] 
     86                 if a.varType==Orange.feature.Type.Continuous] 
    8787        return SpearmanRDistance(domain=table.domain, indxs=indxs) 
    8888 
     
    176176    def __call__(self, data): 
    177177        indxs = [i for i, a in enumerate(data.domain.attributes) \ 
    178                  if a.varType==Orange.data.Type.Continuous] 
     178                 if a.varType==Orange.feature.Type.Continuous] 
    179179        return PearsonRAbsoluteDistance(domain=data.domain, indxs=indxs) 
    180180     
     
    211211    def __call__(self, data): 
    212212        indxs = [i for i, a in enumerate(data.domain.attributes) \ 
    213                  if a.varType==Orange.data.Type.Continuous] 
     213                 if a.varType==Orange.feature.Type.Continuous] 
    214214        return SpearmanRAbsoluteDistance(domain=data.domain, indxs=indxs) 
    215215     
  • Orange/ensemble/bagging.py

    r9919 r9923  
    108108              :class:`Orange.statistics.Distribution` or a tuple with both 
    109109        """ 
    110         if self.class_var.var_type == Orange.data.Type.Discrete: 
     110        if self.class_var.var_type == Orange.feature.Type.Discrete: 
    111111            freq = [0.] * len(self.class_var.values) 
    112112            for c in self.classifiers: 
     
    126126                return value 
    127127             
    128         elif self.class_var.var_type ==Orange.data.Type.Continuous: 
     128        elif self.class_var.var_type ==Orange.feature.Type.Continuous: 
    129129            votes = [c(instance, orange.GetBoth if result_type==\ 
    130130                orange.GetProbabilities else result_type) \ 
  • Orange/evaluation/testing.py

    r9914 r9923  
    109109            self.base_class = self.class_values = None 
    110110            if test_type==TEST_TYPE_SINGLE: 
    111                 if domain.class_var.var_type == Orange.data.Type.Discrete: 
     111                if domain.class_var.var_type == Orange.feature.Type.Discrete: 
    112112                    self.class_values = list(domain.class_var.values) 
    113113                    self.base_class = domain.class_var.base_value 
     
    117117            elif test_type==TEST_TYPE_MLC: 
    118118                self.labels = [var.name for var in domain.class_vars] 
    119                 self.converter = lambda vals: [int(val) if val.variable.var_type == Orange.data.Type.Discrete 
     119                self.converter = lambda vals: [int(val) if val.variable.var_type == Orange.feature.Type.Discrete 
    120120                                               else float(val) for val in vals] 
    121121 
  • Orange/fixes/fix_changed_names.py

    r9920 r9923  
    3434           "orange.Domain": "Orange.data.Domain", 
    3535           "orange.Value": "Orange.data.Value", 
    36            "orange.VarTypes": "Orange.data.Type", 
     36           "orange.VarTypes": "Orange.feature.Type", 
    3737           "orange.Variable": "Orange.feature.Descriptor", 
    3838           "orange.EnumVariable": "Orange.feature.Discrete", 
  • Orange/preprocess/__init__.py

    r9755 r9923  
    3131    declares values that do not appear in the data. 
    3232 
    33     :param variable: :class:`Orange.data.variable.Variable` 
     33    :param variable: :class:`Orange.feature.Descriptor` 
    3434    :param data: :class:`Orange.data.Table` 
    3535    :param remove_one_valued: Decides whether to remove or to retain 
  • Orange/preprocess/scaling.py

    r9702 r9923  
    677677        if self.data_domain.class_var: 
    678678            domain = settings_dict.get("domain") or \ 
    679                      Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    680                                          Orange.data.variable.Continuous("yVar"), 
    681                                          Orange.data.variable.Discrete(self.data_domain.class_var.name, 
     679                     Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     680                                         Orange.feature.Continuous("yVar"), 
     681                                         Orange.feature.Discrete(self.data_domain.class_var.name, 
    682682                                                                       values = get_variable_values_sorted(self.data_domain.class_var))]) 
    683683        else: 
    684684            domain = settings_dict.get("domain") or \ 
    685                      Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    686                                          Orange.data.variable.Continuous("yVar")]) 
     685                     Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     686                                         Orange.feature.Continuous("yVar")]) 
    687687        data = self.create_projection_as_numeric_array(attr_indices, 
    688688                                                       **settings_dict) 
     
    10031003        if self.data_domain.class_var: 
    10041004            domain = settings_dict.get("domain") or \ 
    1005                      Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    1006                                          Orange.data.variable.Continuous("yVar"), 
    1007                                          Orange.data.variable.Continuous("zVar"), 
    1008                                          Orange.data.variable.Discrete(self.data_domain.class_var.name, 
     1005                     Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     1006                                         Orange.feature.Continuous("yVar"), 
     1007                                         Orange.feature.Continuous("zVar"), 
     1008                                         Orange.feature.Discrete(self.data_domain.class_var.name, 
    10091009                                                                       values=get_variable_values_sorted(self.data_domain.class_var))]) 
    10101010        else: 
    10111011            domain = settings_dict.get("domain") or \ 
    1012                      Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    1013                                          Orange.data.variable.Continuous("yVar"), 
    1014                                          Orange.data.variable.Continuous("zVar")]) 
     1012                     Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     1013                                         Orange.feature.Continuous("yVar"), 
     1014                                         Orange.feature.Continuous("zVar")]) 
    10151015        data = self.create_projection_as_numeric_array(attr_indices, 
    10161016                                                       **settings_dict) 
     
    11871187        if self.data_domain.class_var: 
    11881188            domain = settings_dict.get("domain") or \ 
    1189                      Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    1190                                          Orange.data.variable.Continuous("yVar"), 
    1191                                          Orange.data.variable.Discrete(self.data_domain.class_var.name, 
     1189                     Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     1190                                         Orange.feature.Continuous("yVar"), 
     1191                                         Orange.feature.Discrete(self.data_domain.class_var.name, 
    11921192                                                                       values = get_variable_values_sorted(self.data_domain.class_var))]) 
    11931193        else: 
    11941194            domain = settings_dict.get("domain") or \ 
    1195                      Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    1196                                          Orange.data.variable.Continuous("yVar")]) 
     1195                     Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     1196                                         Orange.feature.Continuous("yVar")]) 
    11971197        data = self.create_projection_as_numeric_array(attr_list, **settings_dict) 
    11981198        if data != None: 
     
    14131413        if self.data_has_class: 
    14141414            domain = settings_dict.get("domain") or \ 
    1415                      Orange.data.Domain([Orange.data.variable.Continuous(self.data_domain[attr_indices[0]].name), 
    1416                                          Orange.data.variable.Continuous(self.data_domain[attr_indices[1]].name), 
    1417                                          Orange.data.variable.Discrete(self.data_domain.class_var.name, 
     1415                     Orange.data.Domain([Orange.feature.Continuous(self.data_domain[attr_indices[0]].name), 
     1416                                         Orange.feature.Continuous(self.data_domain[attr_indices[1]].name), 
     1417                                         Orange.feature.Discrete(self.data_domain.class_var.name, 
    14181418                                                                       values = get_variable_values_sorted(self.data_domain.class_var))]) 
    14191419        else: 
    14201420            domain = settings_dict.get("domain") or \ 
    1421                      Orange.data.Domain([Orange.data.variable.Continuous(self.data_domain[attr_indices[0]].name), 
    1422                                          Orange.data.variable.Continuous(self.data_domain[attr_indices[1]].name)]) 
     1421                     Orange.data.Domain([Orange.feature.Continuous(self.data_domain[attr_indices[0]].name), 
     1422                                         Orange.feature.Continuous(self.data_domain[attr_indices[1]].name)]) 
    14231423 
    14241424        data = self.create_projection_as_numeric_array(attr_indices, 
     
    14411441        if self.data_has_class: 
    14421442            domain = settings_dict.get("domain") or \ 
    1443                      Orange.data.Domain([Orange.data.variable.Continuous(self.data_domain[attr_indices[0]].name), 
    1444                                          Orange.data.variable.Continuous(self.data_domain[attr_indices[1]].name), 
    1445                                          Orange.data.variable.Continuous(self.data_domain[attr_indices[2]].name), 
    1446                                          Orange.data.variable.Discrete(self.data_domain.class_var.name, 
     1443                     Orange.data.Domain([Orange.feature.Continuous(self.data_domain[attr_indices[0]].name), 
     1444                                         Orange.feature.Continuous(self.data_domain[attr_indices[1]].name), 
     1445                                         Orange.feature.Continuous(self.data_domain[attr_indices[2]].name), 
     1446                                         Orange.feature.Discrete(self.data_domain.class_var.name, 
    14471447                                                                       values = get_variable_values_sorted(self.data_domain.class_var))]) 
    14481448        else: 
    14491449            domain = settings_dict.get("domain") or \ 
    1450                      Orange.data.Domain([Orange.data.variable.Continuous(self.data_domain[attr_indices[0]].name), 
    1451                                          Orange.data.variable.Continuous(self.data_domain[attr_indices[1]].name), 
    1452                                          Orange.data.variable.Continuous(self.data_domain[attr_indices[2]].name)]) 
     1450                     Orange.data.Domain([Orange.feature.Continuous(self.data_domain[attr_indices[0]].name), 
     1451                                         Orange.feature.Continuous(self.data_domain[attr_indices[1]].name), 
     1452                                         Orange.feature.Continuous(self.data_domain[attr_indices[2]].name)]) 
    14531453 
    14541454        data = self.create_projection_as_numeric_array_3D(attr_indices, 
     
    15281528         
    15291529        jitter_size = 0.001 * self.clusterOptimization.jitterDataBeforeTriangulation 
    1530         domain = Orange.data.Domain([Orange.data.variable.Continuous("xVar"), 
    1531                                      Orange.data.variable.Continuous("yVar"), 
     1530        domain = Orange.data.Domain([Orange.feature.Continuous("xVar"), 
     1531                                     Orange.feature.Continuous("yVar"), 
    15321532                                    self.data_domain.class_var]) 
    15331533 
  • Orange/statistics/contingency.py

    r9671 r9923  
    8282    .. attribute:: varType 
    8383 
    84         The type of the outer variable (:obj:`Orange.data.Type`, usually 
     84        The type of the outer variable (:obj:`Orange.feature.Type`, usually 
    8585        :obj:`Orange.data.variable.Discrete` or 
    8686        :obj:`Orange.data.variable.Continuous`); equals 
  • Orange/statistics/distribution.py

    r9697 r9923  
    356356 
    357357    for d in dist: 
    358         if d.variable.var_type == Orange.data.Type.Discrete: 
     358        if d.variable.var_type == Orange.feature.Type.Discrete: 
    359359             print "%30s: %s" % (d.variable.name, d) 
    360360        else: 
  • Orange/testing/unit/tests/test_variable.py

    r9679 r9923  
    88        """ 
    99        v1, s = Orange.data.variable.make("test_variable_a", 
    10                                       Orange.data.Type.Discrete,["a", "b"]) 
     10                                      Orange.feature.Type.Discrete,["a", "b"]) 
    1111        v2, s = Orange.data.variable.make("test_variable_a", 
    12                                       Orange.data.Type.Discrete, ["a"], ["c"]) 
     12                                      Orange.feature.Type.Discrete, ["a"], ["c"]) 
    1313        self.assertIs(v2, v1) 
    1414         
    1515        v3, s = Orange.data.variable.make("test_variable_a", 
    16                           Orange.data.Type.Discrete, ["a", "b", "c", "d"]) 
     16                          Orange.feature.Type.Discrete, ["a", "b", "c", "d"]) 
    1717        self.assertIs(v3, v1) 
    1818         
    1919        v4, s = Orange.data.variable.make("test_variable_a", 
    20                                      Orange.data.Type.Discrete, ["b"]) 
     20                                     Orange.feature.Type.Discrete, ["b"]) 
    2121        self.assertIsNot(v4, v1) 
    2222         
    2323        v5, s = Orange.data.variable.make("test_variable_a", 
    24                              Orange.data.Type.Discrete, None, ["c", "a"]) 
     24                             Orange.feature.Type.Discrete, None, ["c", "a"]) 
    2525        self.assertIs(v5, v1) 
    2626         
    2727        v6, s = Orange.data.variable.make("test_variable_a",  
    28                             Orange.data.Type.Discrete, None, ["e"]) 
     28                            Orange.feature.Type.Discrete, None, ["e"]) 
    2929        self.assertIs(v6, v1) 
    3030         
    3131        v7, s = Orange.data.variable.make("test_variable_a", 
    32                                  Orange.data.Type.Discrete, None, ["f"], 
    33                                  Orange.data.variable.Variable.MakeStatus.NoRecognizedValues) 
     32                                 Orange.feature.Type.Discrete, None, ["f"], 
     33                                 Orange.feature.Descriptor.MakeStatus.NoRecognizedValues) 
    3434        self.assertIsNot(v7, v1) 
    3535         
    3636        v8, s = Orange.data.variable.make("test_variable_a", 
    37                                      Orange.data.Type.Discrete, 
     37                                     Orange.feature.Type.Discrete, 
    3838                                     ["a", "b", "c", "d", "e"], None, 
    39                                      Orange.data.variable.Variable.MakeStatus.OK) 
     39                                     Orange.feature.Descriptor.MakeStatus.OK) 
    4040        self.assertIsNot(v8, v1) 
    4141         
Note: See TracChangeset for help on using the changeset viewer.