Changeset 9919:8a2a770ef3af in orange


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

data.variable -> feature

Files:
18 edited

Legend:

Unmodified
Added
Removed
  • Orange/associate/__init__.py

    r9671 r9919  
    149149 
    150150This way of representing the itemsets is memory efficient and faster than using 
    151 objects like :obj:`~Orange.data.variable.Variable` and :obj:`~Orange.data.Instance`. 
     151objects like :obj:`~Orange.feature.Descriptor` and :obj:`~Orange.data.Instance`. 
    152152 
    153153.. _non-sparse-examples: 
  • Orange/classification/logreg.py

    r9878 r9919  
    132132        else: 
    133133            lr = learner(instances, weight) 
    134         while isinstance(lr, Orange.data.variable.Variable): 
     134        while isinstance(lr, Orange.feature.Descriptor): 
    135135            if isinstance(lr.getValueFrom, Orange.core.ClassifierFromVar) and isinstance(lr.getValueFrom.transformer, Orange.core.Discrete2Continuous): 
    136136                lr = lr.getValueFrom.variable 
     
    216216                # v dataOrig, dataFinal in new_data dodaj nov atribut -- continuous variable 
    217217                if at.var_type == Orange.data.Type.Continuous: 
    218                     at_disc = Orange.data.variable.Continuous(at.name+ "Disc") 
     218                    at_disc = Orange.feature.Continuous(at.name+ "Disc") 
    219219                    new_domain = Orange.data.Domain(data.domain.features+[at_disc,data.domain.class_var]) 
    220220                    new_domain.addmetas(data.domain.getmetas()) 
     
    230230                elif at.var_type == Orange.data.Type.Discrete: 
    231231                # v dataOrig, dataFinal in new_data atributu "at" dodaj ee  eno  vreednost, ki ima vrednost kar  ime atributa +  "X" 
    232                     at_new = Orange.data.variable.Discrete(at.name, values = at.values + [at.name+"X"]) 
     232                    at_new = Orange.feature.Discrete(at.name, values = at.values + [at.name+"X"]) 
    233233                    new_domain = Orange.data.Domain(filter(lambda x: x!=at, data.domain.features)+[at_new,data.domain.class_var]) 
    234234                    new_domain.addmetas(data.domain.getmetas()) 
     
    336336                # v dataOrig, dataFinal in newData dodaj nov atribut -- continuous variable 
    337337                if at.var_type == Orange.data.Type.Continuous: 
    338                     atDisc = Orange.data.variable.Continuous(at.name + "Disc") 
     338                    atDisc = Orange.feature.Continuous(at.name + "Disc") 
    339339                    newDomain = Orange.data.Domain(orig_data.domain.features+[atDisc,data.domain.class_var]) 
    340340                    newDomain.addmetas(newData.domain.getmetas()) 
     
    353353                elif at.var_type == Orange.data.Type.Discrete: 
    354354                # v dataOrig, dataFinal in newData atributu "at" dodaj ee  eno  vreednost, ki ima vrednost kar  ime atributa +  "X" 
    355                     at_new = Orange.data.variable.Discrete(at.name, values = at.values + [at.name+"X"]) 
     355                    at_new = Orange.feature.Discrete(at.name, values = at.values + [at.name+"X"]) 
    356356                    newDomain = Orange.data.Domain(filter(lambda x: x!=at, orig_data.domain.features)+[at_new,orig_data.domain.class_var]) 
    357357                    newDomain.addmetas(orig_data.domain.getmetas()) 
  • Orange/classification/lookup.py

    r9671 r9919  
    1919 
    2020A natural habitat for these classifiers is feature construction: 
    21 they usually reside in :obj:`~Orange.data.variable.Variable.get_value_from` fields of constructed 
     21they usually reside in :obj:`~Orange.feature.Descriptor.get_value_from` fields of constructed 
    2222features to facilitate their automatic computation. For instance, 
    2323the following script shows how to translate the :download:`monks-1.tab <code/monks-1.tab>` data set 
     
    302302    ['1', '3', '2', '0'] <12.000, 0.000> 
    303303 
    304 ClassifierByDataTable will usually be used by :obj:`Orange.data.variable.Variable.get_value_from`. So, we 
     304ClassifierByDataTable will usually be used by :obj:`Orange.feature.Descriptor.get_value_from`. So, we 
    305305would probably continue this by constructing a new feature and put the 
    306 classifier into its :obj:`Orange.data.variable.Variable.get_value_from`. 
    307  
    308     >>> y2 = Orange.data.variable.Discrete("y2", values = ["0", "1"]) 
     306classifier into its :obj:`Orange.feature.Descriptor.get_value_from`. 
     307 
     308    >>> y2 = Orange.feature.Discrete("y2", values = ["0", "1"]) 
    309309    >>> y2.get_value_from = abe 
    310310 
     
    321321the new class variable and the features that should be used for 
    322322classification. This saves us from constructing data_s and reassigning 
    323 the class_var. It doesn't set the :obj:`Orange.data.variable.Variable.get_value_from`, though. 
     323the class_var. It doesn't set the :obj:`Orange.feature.Descriptor.get_value_from`, though. 
    324324 
    325325part of :download:`lookup-table.py <code/lookup-table.py>` (uses: :download:`monks-1.tab <code/monks-1.tab>`):: 
     
    330330    a, b, e = table.domain["a"], table.domain["b"], table.domain["e"] 
    331331 
    332     y2 = Orange.data.variable.Discrete("y2", values = ["0", "1"]) 
     332    y2 = Orange.feature.Discrete("y2", values = ["0", "1"]) 
    333333    abe2 = Orange.classification.lookup.LookupLearner(y2, [a, b, e], table) 
    334334 
     
    380380    as follows. 
    381381     
    382         >>> newvar = Orange.data.variable.Discrete() 
     382        >>> newvar = Orange.feature.Discrete() 
    383383        >>> bound = [table.domain[name] for name in ["a", "b"]] 
    384384        >>> lookup = lookup_from_bound(newvar, bound) 
     
    407407     
    408408        >>> bound = [table.domain[name] for name in ["a", "b"]] 
    409         >>> newVar = Orange.data.variable.Discrete("a=b", values=["no", "yes"]) 
     409        >>> newVar = Orange.feature.Discrete("a=b", values=["no", "yes"]) 
    410410        >>> lookup = lookup_from_function(newVar, bound, lambda x: x[0] == x[1]) 
    411411        >>> newVar.get_value_from = lookup 
     
    429429    (either when needed by addAnAttribute or at some other place), lookup 
    430430    should be used to compute newVar's value. (A bit off topic, but 
    431     important: you should never call :obj:`Orange.data.variable.Variable.get_value_from` directly, but always call 
     431    important: you should never call :obj:`Orange.feature.Descriptor.get_value_from` directly, but always call 
    432432    it through computeValue.) 
    433433 
     
    450450    dump_lookup_function returns a string with a lookup function in 
    451451    tab-delimited format. Argument func can be any of the above-mentioned 
    452     classifiers or a feature whose :obj:`Orange.data.variable.Variable.get_value_from` points to one of such 
     452    classifiers or a feature whose :obj:`Orange.feature.Descriptor.get_value_from` points to one of such 
    453453    classifiers. 
    454454 
     
    536536         
    537537def dump_lookup_function(func): 
    538     if isinstance(func, Orange.data.variable.Variable): 
     538    if isinstance(func, Orange.feature.Descriptor): 
    539539        if not func.get_value_from: 
    540540            raise TypeError, "attribute '%s' does not have an associated function" % func.name 
  • Orange/classification/rules.py

    r9857 r9919  
    627627def create_dichotomous_class(domain, att, value, negate, removeAtt=None): 
    628628    # create new variable 
    629     newClass = Orange.data.variable.Discrete(att.name + "_", values=[str(value) + "_", "not " + str(value)]) 
     629    newClass = Orange.feature.Discrete(att.name + "_", values=[str(value) + "_", "not " + str(value)]) 
    630630    positive = Orange.data.Value(newClass, str(value) + "_") 
    631631    negative = Orange.data.Value(newClass, "not " + str(value)) 
     
    17331733            weights = Orange.data.new_meta_id() 
    17341734            instances.addMetaAttribute(weights, 1.) 
    1735             instances.domain.addmeta(weights, Orange.data.variable.\ 
     1735            instances.domain.addmeta(weights, Orange.feature.\ 
    17361736                Continuous("weights-" + str(weights)), True) 
    17371737        newWeightsID = Orange.data.new_meta_id() 
    17381738        instances.addMetaAttribute(newWeightsID, 1.) 
    1739         instances.domain.addmeta(newWeightsID, Orange.data.variable.\ 
     1739        instances.domain.addmeta(newWeightsID, Orange.feature.\ 
    17401740            Continuous("weights-" + str(newWeightsID)), True) 
    17411741        for instance in instances: 
     
    17581758            weights = Orange.data.new_meta_id() 
    17591759            instances.addMetaAttribute(weights, 1.) 
    1760             instances.domain.addmeta(weights, Orange.data.variable.\ 
     1760            instances.domain.addmeta(weights, Orange.feature.\ 
    17611761                Continuous("weights-" + str(weights)), True) 
    17621762        try: 
    17631763            coverage = instances.domain.getmeta("Coverage") 
    17641764        except: 
    1765             coverage = Orange.data.variable.Continuous("Coverage") 
     1765            coverage = Orange.feature.Continuous("Coverage") 
    17661766            instances.domain.addmeta(Orange.data.new_meta_id(), coverage, True) 
    17671767            instances.addMetaAttribute(coverage, 0.0) 
    17681768        newWeightsID = Orange.data.new_meta_id() 
    17691769        instances.addMetaAttribute(newWeightsID, 1.) 
    1770         instances.domain.addmeta(newWeightsID, Orange.data.variable.\ 
     1770        instances.domain.addmeta(newWeightsID, Orange.feature.\ 
    17711771            Continuous("weights-" + str(newWeightsID)), True) 
    17721772        for instance in instances: 
     
    17911791        examples.addMetaAttribute(self.prob_attribute, self.apriori_prob) 
    17921792        examples.domain.addmeta(self.prob_attribute, 
    1793             Orange.data.variable.Continuous("Probs")) 
     1793            Orange.feature.Continuous("Probs")) 
    17941794        self.argument_id = argument_id 
    17951795 
  • Orange/classification/svm/__init__.py

    r9671 r9919  
    294294        # Fix the svm_type parameter if we have a class_var/svm_type mismatch 
    295295        if self.svm_type in [0,1] and \ 
    296             isinstance(class_var, Orange.data.variable.Continuous): 
     296            isinstance(class_var, Orange.feature.Continuous): 
    297297            self.svm_type += 3 
    298298            #raise AttributeError, "Cannot learn a discrete classifier from non descrete class data. Use EPSILON_SVR or NU_SVR for regression" 
    299299        if self.svm_type in [3,4] and \ 
    300             isinstance(class_var, Orange.data.variable.Discrete): 
     300            isinstance(class_var, Orange.feature.Discrete): 
    301301            self.svm_type -= 3 
    302302            #raise AttributeError, "Cannot do regression on descrete class data. Use C_SVC or NU_SVC for classification" 
     
    647647            for sv_ind in range(*sv_ranges[i]): 
    648648                attributes = SVs.domain.attributes + \ 
    649                 SVs[sv_ind].getmetas(False, Orange.data.variable.Variable).keys() 
     649                SVs[sv_ind].getmetas(False, Orange.feature.Descriptor).keys() 
    650650                for attr in attributes: 
    651651                    if attr.varType == Orange.data.Type.Continuous: 
     
    655655            for sv_ind in range(*sv_ranges[j]): 
    656656                attributes = SVs.domain.attributes + \ 
    657                 SVs[sv_ind].getmetas(False, Orange.data.variable.Variable).keys() 
     657                SVs[sv_ind].getmetas(False, Orange.feature.Descriptor).keys() 
    658658                for attr in attributes: 
    659659                    if attr.varType==Orange.data.Type.Continuous: 
  • Orange/classification/tree.py

    r9671 r9919  
    10161016a regression tree does not always predict the leaf average, but whatever 
    10171017the :obj:`~Node.node_classifier` in a leaf returns.  As ``%V`` uses the 
    1018 :obj:`Orange.data.variable.Continuous`' function for printing the 
     1018:obj:`Orange.feature.Continuous`' function for printing the 
    10191019value, the number has the same number of decimals as in the data file. 
    10201020 
     
    26592659        if self.class_var.var_type == Orange.data.Type.Discrete: 
    26602660            domain = Orange.data.Domain([self.class_var] + 
    2661                 [Orange.data.variable.Continuous(name) for name in 
     2661                [Orange.feature.Continuous(name) for name in 
    26622662                 ["instances", "majority proportion"] + list(self.class_var.values)], None) 
    26632663        else: 
    26642664            domain = Orange.data.Domain([self.class_var] + 
    2665                 [Orange.data.variable.Continuous(name) for name in 
     2665                [Orange.feature.Continuous(name) for name in 
    26662666                 ["error", "instances"]], None) 
    26672667        domain = Orange.data.Domain(domain) 
  • Orange/clustering/mixture.py

    r9671 r9919  
    321321        self.domain = domain 
    322322        self.norm_model = norm_model 
    323         self.cluster_vars = [Orange.data.variable.Continuous("cluster %i" % i)\ 
     323        self.cluster_vars = [Orange.feature.Continuous("cluster %i" % i)\ 
    324324                             for i in range(len(norm_model))] 
    325325        self.weights = self.norm_model.weights 
  • Orange/data/io.py

    r9799 r9919  
    6666The signature for the custom load functions should be 
    6767 
    68 ``load_myformat(filename, create_new_on=Variable.MakeStatus.NoRecognizedValues, **kwargs)`` 
    69      
    70 When constructing variables :obj:`Orange.data.variable.make` should  
     68``load_myformat(filename, create_new_on=Orange.feature.Descriptor.MakeStatus.NoRecognizedValues, **kwargs)`` 
     69     
     70When constructing variables :obj:`Orange.feature.Descriptor.make` should  
    7171be used with the ``create_new_on`` parameter.  
    72 :obj:`~Orange.data.variable.make` will return an attribute and the  
     72:obj:`~Orange.feature.Descriptor.make` will return an attribute and the  
    7373status of the variable, telling whether a new attribute was created  
    74 or the old one reused and why (see :mod:`Orange.data.variable`).  
     74or the old one reused and why (see :mod:`Orange.feature`).  
    7575Additional keyword arguments can be provided in the call to  
    7676:obj:`~Orange.data.Table` constructor. These will be passed in the  
     
    9090 
    9191import Orange 
    92 import Orange.data.variable 
     92import Orange.feature 
    9393import Orange.misc 
    9494from Orange.core import \ 
     
    9898 
    9999from Orange.data import variable 
    100 from Orange.data.variable import Variable 
    101 MakeStatus = Variable.MakeStatus 
     100from Orange.feature import Descriptor 
     101MakeStatus = Orange.feature.Descriptor.MakeStatus 
     102make = Orange.feature.Descriptor.make 
    102103 
    103104def loadARFF(filename, create_on_new=MakeStatus.Incompatible, **kwargs): 
     
    115116        return loadARFF_Weka(filename, create_on_new) 
    116117 
    117 def loadARFF_Weka(filename, create_on_new=Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
     118def loadARFF_Weka(filename, create_on_new=MakeStatus.Incompatible, **kwargs): 
    118119    """Return class:`Orange.data.Table` containing data from file in Weka ARFF format""" 
    119120    if not os.path.exists(filename) and os.path.exists(filename + ".arff"): 
     
    190191                        if len(sy) > 0: 
    191192                            vals.append(sy) 
    192                     a, s = Variable.make(atn, Orange.data.Type.Discrete, vals, [], create_on_new) 
     193                    a, s = make(atn, Orange.data.Type.Discrete, vals, [], create_on_new) 
    193194                else: 
    194195                    # real... 
    195                     a, s = Variable.make(atn, Orange.data.Type.Continuous, [], [], create_on_new) 
     196                    a, s = make(atn, Orange.data.Type.Continuous, [], [], create_on_new) 
    196197 
    197198                attributes.append(a) 
     
    270271        f.write('%s\n' % x[-1]) 
    271272 
    272 def loadMULAN(filename, create_on_new=Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
     273def loadMULAN(filename, create_on_new=MakeStatus.Incompatible, **kwargs): 
    273274    """Return class:`Orange.data.Table` containing data from file in Mulan ARFF and XML format""" 
    274275    if filename[-4:] == ".xml": 
     
    398399    attributeLoadStatus = {} 
    399400    def make_float(name): 
    400         attr, s = Orange.data.variable.make(name, Orange.data.Type.Continuous, [], [], create_on_new) 
     401        attr, s = Orange.feature.Descriptor.make(name, Orange.data.Type.Continuous, [], [], create_on_new) 
    401402        attributeLoadStatus[attr] = s 
    402403        return attr 
    403404 
    404405    def make_disc(name, unordered): 
    405         attr, s = Orange.data.variable.make(name, Orange.data.Type.Discrete, [], unordered, create_on_new) 
     406        attr, s = Orange.feature.Descriptor.make(name, Orange.data.Type.Discrete, [], unordered, create_on_new) 
    406407        attributeLoadStatus[attr] = s 
    407408        return attr 
     
    478479        return variable.Python 
    479480    elif cell == "": 
    480         return variable.Variable 
     481        return variable.Descriptor 
    481482    elif len(cell.split(",")) > 1: 
    482483        return variable.Discrete, cell.split(",") 
  • Orange/ensemble/bagging.py

    r9733 r9919  
    8686     
    8787    :param class_var: the class feature. 
    88     :type class_var: :class:`Orange.data.variable.Variable` 
     88    :type class_var: :class:`Orange.feature.Descriptor` 
    8989 
    9090    """ 
  • Orange/ensemble/boosting.py

    r9733 r9919  
    110110     
    111111    :param class_var: the class feature. 
    112     :type class_var: :class:`Orange.data.variable.Variable` 
     112    :type class_var: :class:`Orange.feature.Descriptor` 
    113113     
    114114    """ 
  • Orange/ensemble/forest.py

    r9733 r9919  
    194194     
    195195    :param class_var: the class feature. 
    196     :type class_var: :class:`Orange.data.variable.Variable` 
     196    :type class_var: :class:`Orange.feature.Descriptor` 
    197197 
    198198    """ 
     
    220220        # handle discreete class 
    221221         
    222         if self.class_var.var_type == Orange.data.variable.Discrete.Discrete: 
     222        if self.class_var.var_type == Orange.feature.Discrete.Discrete: 
    223223         
    224224            # voting for class probabilities 
     
    336336         
    337337        :param feature: feature to evaluate (by index, name or 
    338             :class:`Orange.data.variable.Variable` object). 
    339         :type feature: int, str or :class:`Orange.data.variable.Variable`. 
     338            :class:`Orange.feature.Descriptor` object). 
     339        :type feature: int, str or :class:`Orange.feature.Descriptor`. 
    340340         
    341341        :param instances: data instances to use for importance evaluation. 
     
    352352          attrName = feature 
    353353          attrNo = instances.domain.index(attrName) 
    354         elif isinstance(feature, Orange.data.variable.Variable): 
     354        elif isinstance(feature, Orange.feature.Descriptor): 
    355355          atrs = [a for a in instances.domain.attributes] 
    356356          attrNo = atrs.index(feature) 
     
    512512        if not bcopy.measure: 
    513513            bcopy.measure = Orange.feature.scoring.Gini() \ 
    514                 if isinstance(instances.domain.class_var, Orange.data.variable.Discrete) \ 
     514                if isinstance(instances.domain.class_var, Orange.feature.Discrete) \ 
    515515                else Orange.feature.scoring.MSE() 
    516516 
  • Orange/evaluation/reliability.py

    r9816 r9919  
    698698        new_domain = None 
    699699         
    700         if instances.domain.class_var.var_type != Orange.data.variable.Continuous.Continuous: 
     700        if instances.domain.class_var.var_type != Orange.feature.Continuous.Continuous: 
    701701            raise Exception("This method only works on data with continuous class.") 
    702702         
  • Orange/feature/__init__.py

    r9918 r9919  
    1717 
    1818from Orange.core import newmetaid as new_meta_id 
    19  
    20 from Orange.core import Variable as V 
    21 make = V.make 
    22 retrieve = V.get_existing 
    23 MakeStatus = V.MakeStatus 
    24 del V 
     19from Orange.core import VarTypes as Type 
    2520 
    2621__docformat__ = 'restructuredtext' 
  • Orange/feature/scoring.py

    r9813 r9919  
    9191    :param attribute: the chosen feature, either as a descriptor,  
    9292      index, or a name. 
    93     :type attribute: :class:`Orange.data.variable.Variable` or int or string 
     93    :type attribute: :class:`Orange.feature.Descriptor` or int or string 
    9494    :param data: data. 
    9595    :type data: `Orange.data.Table` 
     
    102102    :param attribute: the chosen feature, either as a descriptor,  
    103103      index, or a name. 
    104     :type attribute: :class:`Orange.data.variable.Variable` or int or string 
     104    :type attribute: :class:`Orange.feature.Descriptor` or int or string 
    105105    :param domain_contingency:  
    106106    :type domain_contingency: :obj:`Orange.statistics.contingency.Domain` 
     
    469469 
    470470        :param weight: meta attribute that stores weights of instances 
    471         :type weight: Orange.data.variable.Variable 
     471        :type weight: Orange.feature.Descriptor 
    472472 
    473473        """ 
     
    508508 
    509509        :param attr: feature to score 
    510         :type attr: Orange.data.variable.Variable 
     510        :type attr: Orange.feature.Descriptor 
    511511 
    512512        :param data: a data table used to score features 
     
    517517         
    518518        :param weightID: meta feature used to weight individual data instances 
    519         :type weightID: Orange.data.variable.Variable 
     519        :type weightID: Orange.feature.Descriptor 
    520520 
    521521        """ 
     
    565565 
    566566        :param attr: feature to score 
    567         :type attr: Orange.data.variable.Variable 
     567        :type attr: Orange.feature.Descriptor 
    568568 
    569569        :param data: a data table used to score the feature 
     
    574574         
    575575        :param weightID: meta feature used to weight individual data instances 
    576         :type weightID: Orange.data.variable.Variable 
     576        :type weightID: Orange.feature.Descriptor 
    577577 
    578578        """ 
  • Orange/misc/r.py

    r9671 r9919  
    5050        return na if value.isSpecial() else fn(value) 
    5151     
    52     if attr.var_type == Orange.data.variable.Variable.Continuous: 
     52    if attr.var_type == Orange.feature.Descriptor.Continuous: 
    5353        return robjects.FloatVector([cv(ex[attr], float, NA_Real) for ex in data]) 
    54     elif attr.var_type == Orange.data.variable.Variable.Discrete: 
     54    elif attr.var_type == Orange.feature.Descriptor.Discrete: 
    5555        return robjects.r("factor")(robjects.StrVector([cv(ex[attr], str, NA_Char) for ex in data])) 
    56     elif attr.var_type == Orange.data.variable.Variable.String: 
     56    elif attr.var_type == Orange.feature.Descriptor.String: 
    5757        return robjects.StrVector([cv(ex[attr], str, NA_Char) for ex in data]) 
    5858    else: 
     
    6666    if not variables: 
    6767        variables = [ attr for attr in data.domain.variables if attr.var_type in \ 
    68                  [ Orange.data.variable.Variable.Continuous,  
    69                    Orange.data.variable.Variable.Discrete,  
    70                    Orange.data.variable.Variable.String ] ] 
     68                 [ Orange.feature.Descriptor.Continuous,  
     69                   Orange.feature.Descriptor.Discrete,  
     70                   Orange.feature.Descriptor.String ] ] 
    7171            
    7272    odata = [] 
  • Orange/misc/testing.py

    r9671 r9919  
    358358        """ Default test case for Orange learners. 
    359359        """ 
    360         if isinstance(dataset.domain.class_var, Orange.data.variable.Discrete): 
     360        if isinstance(dataset.domain.class_var, Orange.feature.Discrete): 
    361361            indices = _MakeRandomIndices2(p0=0.3, stratified=True)(dataset) 
    362362        else: 
     
    410410         
    411411        for ex in test: 
    412             if isinstance(dataset.domain.class_var, Orange.data.variable.Continuous): 
     412            if isinstance(dataset.domain.class_var, Orange.feature.Continuous): 
    413413                # Test to third digit after the decimal point 
    414414                self.assertAlmostEqual(classifier(ex, orange.GetValue).native(), 
  • Orange/multilabel/mulan.py

    r9671 r9919  
    33from xml.dom.minidom import Node 
    44 
    5 def trans_mulan_data(xml_name,arff_name, create_on_new = Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
     5def trans_mulan_data(xml_name,arff_name, create_on_new = Orange.feature.MakeStatus.Incompatible, **kwargs): 
    66    """ Transform the mulan data format to Tab file. 
    77     
  • source/orange/_aliases.txt

    r9752 r9919  
    6969ExamplesDistance_Normalized 
    7070feature_distances attribute_distances 
     71 
     72Variable 
     73retrieve get_existing 
Note: See TracChangeset for help on using the changeset viewer.