Ignore:
Timestamp:
03/02/11 01:44:16 (3 years ago)
Author:
janezd <janez.demsar@…>
Branch:
default
Convert:
6ceaa13542b467cc96ac23a26920312a7075c442
Message:

Most C++ classes which are exported through the new modules now show the "correct" names.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • source/orange/lib_learner.cpp

    r7665 r7715  
    5353 
    5454#include "majority.hpp" 
    55 C_CALL(MajorityLearner, Learner, "([examples] [, weight=, estimate=]) -/-> Classifier") 
    56 C_CALL(CostLearner, Learner, "([examples] [, weight=, estimate=, costs=]) -/-> Classifier") 
     55C_CALL(MajorityLearner - Orange.classification.majority.MajorityLearner, Learner, "([examples] [, weight=, estimate=]) -/-> Classifier") 
     56C_CALL(CostLearner - Orange.wrappers.CostLearner, Learner, "([examples] [, weight=, estimate=, costs=]) -/-> Classifier") 
    5757 
    5858 
    5959#include "costwrapper.hpp" 
    60 C_CALL(CostWrapperLearner, Learner, "([examples] [, weight=, costs=]) -/-> Classifier") 
    61 C_NAMED(CostWrapperClassifier, Classifier, "([classifier=, costs=])") 
     60C_CALL(CostWrapperLearner - Orange.wrappers.CostWrapperLearner, Learner, "([examples] [, weight=, costs=]) -/-> Classifier") 
     61C_NAMED(CostWrapperClassifier - Orange.wrappers.CostWrapperClassifier, Classifier, "([classifier=, costs=])") 
    6262 
    6363 
     
    6565 
    6666#include "assoc.hpp" 
    67 C_CALL(AssociationLearner, Learner, "([examples] [, weight=, conf=, supp=, voteWeight=]) -/-> Classifier") 
    68 C_NAMED(AssociationClassifier, ClassifierFD, "([rules=, voteWeight=])") 
    69 C_CALL3(AssociationRulesInducer, AssociationRulesInducer, Orange, "([examples[, weightID]], confidence=, support=]) -/-> AssociationRules") 
    70 C_CALL3(AssociationRulesSparseInducer, AssociationRulesSparseInducer, Orange, "([examples[, weightID]], confidence=, support=]) -/-> AssociationRules") 
    71 C_CALL3(ItemsetsSparseInducer, ItemsetsSparseInducer, Orange, "([examples[, weightID]], support=]) -/-> AssociationRules") 
    72  
    73 BASED_ON(ItemsetNodeProxy, Orange) 
     67C_CALL(AssociationLearner - Orange.classification.rules.AssociationLearner, Learner, "([examples] [, weight=, conf=, supp=, voteWeight=]) -/-> Classifier") 
     68C_NAMED(AssociationClassifier - Orange.classification.rules.AssociationClassifier, ClassifierFD, "([rules=, voteWeight=])") 
     69C_CALL3(AssociationRulesInducer - Orange.associate.AssociationRulesInducer, AssociationRulesInducer, Orange, "([examples[, weightID]], confidence=, support=]) -/-> AssociationRules") 
     70C_CALL3(AssociationRulesSparseInducer - Orange.associate.AssociationRulesSparseInducer, AssociationRulesSparseInducer, Orange, "([examples[, weightID]], confidence=, support=]) -/-> AssociationRules") 
     71C_CALL3(ItemsetsSparseInducer - Orange.associate.ItemsSparseInducer, ItemsetsSparseInducer, Orange, "([examples[, weightID]], support=]) -/-> AssociationRules") 
     72 
     73BASED_ON(ItemsetNodeProxy - Orange.associate.ItemsetNodeProxy, Orange) 
    7474 
    7575bool operator < (const TAssociationRule &, const TAssociationRule &) { return false; } 
     
    340340bool convertFromPython(PyObject *, PAssociationRule &); 
    341341 
    342 PyObject *AssociationRule_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(Orange, "(left, right, support, confidence)") 
     342PyObject *AssociationRule_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(Orange - Orange.associate.AssociationRule, "(left, right, support, confidence)") 
    343343{ PyTRY 
    344344    PAssociationRule rule; 
     
    501501PAssociationRules PAssociationRules_FromArguments(PyObject *arg) { return ListOfWrappedMethods<PAssociationRules, TAssociationRules, PAssociationRule, &PyOrAssociationRule_Type>::P_FromArguments(arg); } 
    502502PyObject *AssociationRules_FromArguments(PyTypeObject *type, PyObject *arg) { return ListOfWrappedMethods<PAssociationRules, TAssociationRules, PAssociationRule, &PyOrAssociationRule_Type>::_FromArguments(type, arg); } 
    503 PyObject *AssociationRules_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange, "(<list of AssociationRule>)")  ALLOWS_EMPTY { return ListOfWrappedMethods<PAssociationRules, TAssociationRules, PAssociationRule, &PyOrAssociationRule_Type>::_new(type, arg, kwds); } 
     503PyObject *AssociationRules_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange - Orange.associate.AssociationRules, "(<list of AssociationRule>)")  ALLOWS_EMPTY { return ListOfWrappedMethods<PAssociationRules, TAssociationRules, PAssociationRule, &PyOrAssociationRule_Type>::_new(type, arg, kwds); } 
    504504PyObject *AssociationRules_getitem_sq(TPyOrange *self, Py_ssize_t index) { return ListOfWrappedMethods<PAssociationRules, TAssociationRules, PAssociationRule, &PyOrAssociationRule_Type>::_getitem(self, index); } 
    505505int       AssociationRules_setitem_sq(TPyOrange *self, Py_ssize_t index, PyObject *item) { return ListOfWrappedMethods<PAssociationRules, TAssociationRules, PAssociationRule, &PyOrAssociationRule_Type>::_setitem(self, index, item); } 
     
    533533#include "callback.hpp" 
    534534 
    535 C_CALL(TreeLearner, Learner, "([examples] [, weight=, split=, stop=, nodeLearner=, lookDownOnUnknown=]) -/-> Classifier") 
    536  
    537 C_NAMED(TreeNode, Orange, "([lookDownOnUnknown=, branchSelector=, nodeClassifier=, branches=, contingency=])") 
    538 C_NAMED(TreeClassifier, ClassifierFD, "([domain=, tree=, descender=])") 
    539  
    540 C_NAMED(TreeStopCriteria_common, TreeStopCriteria, "([maxMajority=, minExamples=])") 
    541 HIDDEN(TreeStopCriteria_Python, TreeStopCriteria) 
     535C_CALL(TreeLearner - Orange.core.TreeLearner, Learner, "([examples] [, weight=, split=, stop=, nodeLearner=, lookDownOnUnknown=]) -/-> Classifier") 
     536 
     537C_NAMED(TreeNode - Orange.classification.tree.Node, Orange, "([lookDownOnUnknown=, branchSelector=, nodeClassifier=, branches=, contingency=])") 
     538C_NAMED(TreeClassifier - Orange.classification.tree.TreeClassifier, ClassifierFD, "([domain=, tree=, descender=])") 
     539 
     540C_NAMED(TreeStopCriteria_common - Orange.classification.tree.StopCriteria_common, TreeStopCriteria, "([maxMajority=, minExamples=])") 
     541HIDDEN(TreeStopCriteria_Python - Orange.classification.tree.StopCriteria_Python, TreeStopCriteria) 
    542542NO_PICKLE(TreeStopCriteria_Python) 
    543543 
    544 C_CALL(TreeSplitConstructor_Combined, TreeSplitConstructor, "([examples, [weight, domainContingency, apriorClass, candidates] [discreteTreeSplitConstructor=, continuousTreeSplitConstructor=]) -/-> (Classifier, descriptions, sizes, quality)") 
    545  
    546 ABSTRACT(TreeSplitConstructor_Measure, TreeSplitConstructor) 
    547 C_CALL(TreeSplitConstructor_Attribute, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
    548 C_CALL(TreeSplitConstructor_ExhaustiveBinary, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
    549 C_CALL(TreeSplitConstructor_OneAgainstOthers, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
    550 C_CALL(TreeSplitConstructor_Threshold, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
    551 PYXTRACT_IGNORE C_CALL(TreeSplitConstructor_LR, TreeSplitConstructor, "([minSubset=])") 
    552  
    553 BASED_ON(TreeExampleSplitter, Orange) 
    554  
    555 C_CALL(TreeExampleSplitter_IgnoreUnknowns, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
    556 C_CALL(TreeExampleSplitter_UnknownsToCommon, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
    557 C_CALL(TreeExampleSplitter_UnknownsToAll, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
    558 C_CALL(TreeExampleSplitter_UnknownsToRandom, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
    559 C_CALL(TreeExampleSplitter_UnknownsToBranch, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
    560  
    561 C_CALL(TreeExampleSplitter_UnknownsAsBranchSizes, TreeExampleSplitter, "([branchIndex, node, examples[, weight]]) -/-> (ExampleGenerator, [list of weight ID's])") 
    562 C_CALL(TreeExampleSplitter_UnknownsAsSelector, TreeExampleSplitter, "([branchIndex, node, examples[, weight]]) -/-> (ExampleGenerator, [list of weight ID's])") 
    563  
    564 C_CALL(TreeDescender_UnknownToBranch, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
    565 C_CALL(TreeDescender_UnknownToCommonBranch, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
    566 C_CALL(TreeDescender_UnknownToCommonSelector, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
    567 C_CALL(TreeDescender_UnknownMergeAsBranchSizes, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
    568 C_CALL(TreeDescender_UnknownMergeAsSelector, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
    569  
    570 ABSTRACT(TreePruner, Orange) 
    571 C_CALL (TreePruner_SameMajority, TreePruner, "([tree]) -/-> tree") 
    572 C_CALL (TreePruner_m, TreePruner, "([tree]) -/-> tree") 
     544C_CALL(TreeSplitConstructor_Combined - Orange.classification.tree.SplitConstructor_Combined, TreeSplitConstructor, "([examples, [weight, domainContingency, apriorClass, candidates] [discreteTreeSplitConstructor=, continuousTreeSplitConstructor=]) -/-> (Classifier, descriptions, sizes, quality)") 
     545 
     546ABSTRACT(TreeSplitConstructor_Measure - Orange.classification.tree.SplitConstructor_Measure, TreeSplitConstructor) 
     547C_CALL(TreeSplitConstructor_Attribute - Orange.classification.tree.SplitConstructor_Attribute, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
     548C_CALL(TreeSplitConstructor_ExhaustiveBinary - Orange.classification.tree.SplitConstructor_ExhaustiveBinary, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
     549C_CALL(TreeSplitConstructor_OneAgainstOthers - Orange.classification.tree.SplitConstructor_OneAgainstOthers, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
     550C_CALL(TreeSplitConstructor_Threshold - Orange.classification.tree.SplitConstructor_Threshold, TreeSplitConstructor_Measure, "([measure=, worstAcceptable=, minSubset=])") 
     551PYXTRACT_IGNORE C_CALL(TreeSplitConstructor_LR - Orange.classification.tree.SplitConstructor_LR, TreeSplitConstructor, "([minSubset=])") 
     552 
     553BASED_ON(TreeExampleSplitter - Orange.classification.tree.Splitter, Orange) 
     554 
     555C_CALL(TreeExampleSplitter_IgnoreUnknowns - Orange.classification.tree.Splitter_IgnoreUnknowns, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
     556C_CALL(TreeExampleSplitter_UnknownsToCommon - Orange.classification.tree.Splitter_UnknownsToCommon, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
     557C_CALL(TreeExampleSplitter_UnknownsToAll - Orange.classification.tree.Splitter_UnknownsToAll, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
     558C_CALL(TreeExampleSplitter_UnknownsToRandom - Orange.classification.tree.Splitter_UnknownsToRandom, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
     559C_CALL(TreeExampleSplitter_UnknownsToBranch - Orange.classification.tree.Splitter_UnknownsToBranch, TreeExampleSplitter, "([node, examples[, weight]]) -/-> (ExampleGeneratorList, [list of weight ID's])") 
     560 
     561C_CALL(TreeExampleSplitter_UnknownsAsBranchSizes - Orange.classification.tree.Splitter_UnknownsAsBranchSizes, TreeExampleSplitter, "([branchIndex, node, examples[, weight]]) -/-> (ExampleGenerator, [list of weight ID's])") 
     562C_CALL(TreeExampleSplitter_UnknownsAsSelector - Orange.classification.tree.Splitter_UnknownsAsSelector, TreeExampleSplitter, "([branchIndex, node, examples[, weight]]) -/-> (ExampleGenerator, [list of weight ID's])") 
     563 
     564C_CALL(TreeDescender_UnknownToBranch - Orange.classification.tree.Descender_Unknown, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
     565C_CALL(TreeDescender_UnknownToCommonBranch - Orange.classification.tree.Descender_UnknownToCommonBranch, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
     566C_CALL(TreeDescender_UnknownToCommonSelector - Orange.classification.tree.Descender_UnknownToCommonSelector, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
     567C_CALL(TreeDescender_UnknownMergeAsBranchSizes - Orange.classification.tree.Descender_UnknownMergeAsBranchSizes, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
     568C_CALL(TreeDescender_UnknownMergeAsSelector - Orange.classification.tree.Descender_UnknownMergeAsSelector, TreeDescender, "(node, example) -/-> (node, {distribution | None})") 
     569 
     570ABSTRACT(TreePruner - Orange.classification.tree.Pruner, Orange) 
     571C_CALL (TreePruner_SameMajority - Orange.classification.tree.Pruner_SameMajority, TreePruner, "([tree]) -/-> tree") 
     572C_CALL (TreePruner_m - Orange.classification.tree.Pruner_m, TreePruner, "([tree]) -/-> tree") 
    573573 
    574574 
     
    588588 
    589589 
    590 PyObject *TreeStopCriteria_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "()") 
     590PyObject *TreeStopCriteria_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.tree.StopCriteria, "()") 
    591591{ if (type == (PyTypeObject *)&PyOrTreeStopCriteria_Type) { 
    592592      PyObject *name=NULL; 
     
    672672 
    673673 
    674 PyObject *TreeSplitConstructor_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     674PyObject *TreeSplitConstructor_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.tree.SplitConstructor, "<abstract>") 
    675675{ if (type == (PyTypeObject *)&PyOrTreeSplitConstructor_Type) 
    676676    return setCallbackFunction(WrapNewOrange(mlnew TTreeSplitConstructor_Python(), type), args); 
     
    734734 
    735735 
    736 PyObject *TreeExampleSplitter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     736PyObject *TreeExampleSplitter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.tree.Splitter, "<abstract>") 
    737737{ if (type == (PyTypeObject *)&PyOrTreeExampleSplitter_Type) 
    738738    return setCallbackFunction(WrapNewOrange(mlnew TTreeExampleSplitter_Python(), type), args); 
     
    785785 
    786786 
    787 PyObject *TreeDescender_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     787PyObject *TreeDescender_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.tree.Descender, "<abstract>") 
    788788{ if (type == (PyTypeObject *)&PyOrTreeDescender_Type) 
    789789    return setCallbackFunction(WrapNewOrange(mlnew TMeasureAttribute_Python(), type), args); 
     
    865865PTreeNodeList PTreeNodeList_FromArguments(PyObject *arg) { return ListOfWrappedMethods<PTreeNodeList, TTreeNodeList, PTreeNode, &PyOrTreeNode_Type>::P_FromArguments(arg); } 
    866866PyObject *TreeNodeList_FromArguments(PyTypeObject *type, PyObject *arg) { return ListOfWrappedMethods<PTreeNodeList, TTreeNodeList, PTreeNode, &PyOrTreeNode_Type>::_FromArguments(type, arg); } 
    867 PyObject *TreeNodeList_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange, "(<list of TreeNode>)")  ALLOWS_EMPTY { return ListOfWrappedMethods<PTreeNodeList, TTreeNodeList, PTreeNode, &PyOrTreeNode_Type>::_new(type, arg, kwds); } 
     867PyObject *TreeNodeList_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange - Orange.classification.tree.NodeList, "(<list of TreeNode>)")  ALLOWS_EMPTY { return ListOfWrappedMethods<PTreeNodeList, TTreeNodeList, PTreeNode, &PyOrTreeNode_Type>::_new(type, arg, kwds); } 
    868868PyObject *TreeNodeList_getitem_sq(TPyOrange *self, Py_ssize_t index) { return ListOfWrappedMethods<PTreeNodeList, TTreeNodeList, PTreeNode, &PyOrTreeNode_Type>::_getitem(self, index); } 
    869869int       TreeNodeList_setitem_sq(TPyOrange *self, Py_ssize_t index, PyObject *item) { return ListOfWrappedMethods<PTreeNodeList, TTreeNodeList, PTreeNode, &PyOrTreeNode_Type>::_setitem(self, index, item); } 
     
    895895#include "c4.5.hpp" 
    896896 
    897 C_CALL(C45Learner, Learner, "([examples] [, weight=, gainRatio=, subset=, batch=, probThresh=, minObjs=, window=, increment=, cf=, trials=]) -/-> Classifier") 
    898 C_NAMED(C45Classifier, Classifier, "()") 
     897C_CALL(C45Learner - Orange.classification.tree.C45Learner, Learner, "([examples] [, weight=, gainRatio=, subset=, batch=, probThresh=, minObjs=, window=, increment=, cf=, trials=]) -/-> Classifier") 
     898C_NAMED(C45Classifier - Orange.classification.tree.C45Classifier, Classifier, "()") 
    899899 
    900900PyObject *C45Learner_command_line(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(line) -> None") 
     
    909909} 
    910910 
    911 C_NAMED(C45TreeNode, Orange, "") 
     911C_NAMED(C45TreeNode - Orange.classification.tree.C45Node, Orange, "") 
    912912 
    913913PC45TreeNodeList PC45TreeNodeList_FromArguments(PyObject *arg) { return ListOfWrappedMethods<PC45TreeNodeList, TC45TreeNodeList, PC45TreeNode, &PyOrC45TreeNode_Type>::P_FromArguments(arg); } 
    914914PyObject *C45TreeNodeList_FromArguments(PyTypeObject *type, PyObject *arg) { return ListOfWrappedMethods<PC45TreeNodeList, TC45TreeNodeList, PC45TreeNode, &PyOrC45TreeNode_Type>::_FromArguments(type, arg); } 
    915 PyObject *C45TreeNodeList_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange, "(<list of C45TreeNode>)") ALLOWS_EMPTY { return ListOfWrappedMethods<PC45TreeNodeList, TC45TreeNodeList, PC45TreeNode, &PyOrC45TreeNode_Type>::_new(type, arg, kwds); } 
     915PyObject *C45TreeNodeList_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange - Orange.classification.tree.C45NodeList, "(<list of C45TreeNode>)") ALLOWS_EMPTY { return ListOfWrappedMethods<PC45TreeNodeList, TC45TreeNodeList, PC45TreeNode, &PyOrC45TreeNode_Type>::_new(type, arg, kwds); } 
    916916PyObject *C45TreeNodeList_getitem_sq(TPyOrange *self, Py_ssize_t index) { return ListOfWrappedMethods<PC45TreeNodeList, TC45TreeNodeList, PC45TreeNode, &PyOrC45TreeNode_Type>::_getitem(self, index); } 
    917917int       C45TreeNodeList_setitem_sq(TPyOrange *self, Py_ssize_t index, PyObject *item) { return ListOfWrappedMethods<PC45TreeNodeList, TC45TreeNodeList, PC45TreeNode, &PyOrC45TreeNode_Type>::_setitem(self, index, item); } 
     
    942942 
    943943#include "knn.hpp" 
    944 C_CALL(kNNLearner, Learner, "([examples] [k=, weightID=, findNearest=] -/-> Classifier") 
    945 C_NAMED(kNNClassifier, ClassifierFD, "(example[, returnWhat]) -> prediction") 
     944C_CALL(kNNLearner - Orange.classification.knn.kNNLearner, Learner, "([examples] [k=, weightID=, findNearest=] -/-> Classifier") 
     945C_NAMED(kNNClassifier - Orange.classification.knn.kNNClassifier, ClassifierFD, "(example[, returnWhat]) -> prediction") 
    946946 
    947947 
     
    952952#include "pnn.hpp" 
    953953 
    954 PyObject *P2NN_new(PyTypeObject *type, PyObject *args, PyObject *keywords) BASED_ON(ClassifierFD, "(examples, anchors[, domain]) -> PNN") 
     954PyObject *P2NN_new(PyTypeObject *type, PyObject *args, PyObject *keywords) BASED_ON(ClassifierFD - Orange.classification.knn.P2NN, "(examples, anchors[, domain]) -> PNN") 
    955955{ 
    956956  PyTRY 
     
    11791179 
    11801180#include "logistic.hpp" 
    1181 C_CALL(LogRegLearner, Learner, "([examples[, weight=]]) -/-> Classifier") 
    1182 C_NAMED(LogRegClassifier, ClassifierFD, "([probabilities=])") 
    1183  
    1184  
    1185 PyObject *LogRegFitter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1181C_CALL(LogRegLearner - Orange.classification.logreg.LogRegLearner, Learner, "([examples[, weight=]]) -/-> Classifier") 
     1182C_NAMED(LogRegClassifier - Orange.classification.logreg.LogRegClassifier, ClassifierFD, "([probabilities=])") 
     1183 
     1184 
     1185PyObject *LogRegFitter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.logreg.LogRegFitter, "<abstract>") 
    11861186{ if (type == (PyTypeObject *)&PyOrLogRegFitter_Type) 
    11871187    return setCallbackFunction(WrapNewOrange(mlnew TLogRegFitter_Python(), type), args); 
     
    11961196 
    11971197 
    1198 C_CALL(LogRegFitter_Cholesky, LogRegFitter, "([example[, weightID]]) -/-> (status, beta, beta_se, likelihood) | (status, attribute)") 
     1198C_CALL(LogRegFitter_Cholesky - Orange.classification.logreg.LogRegFitter_Cholesky, LogRegFitter, "([example[, weightID]]) -/-> (status, beta, beta_se, likelihood) | (status, attribute)") 
    11991199 
    12001200PyObject *LogRegLearner_fitModel(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(examples[, weight])") 
     
    12521252/************ Linear **********/ 
    12531253#include "linear.hpp" 
    1254 C_CALL(LinearLearner, Learner, "([examples] -/-> Classifier)") 
    1255 C_NAMED(LinearClassifier, ClassifierFD, " ") 
     1254C_CALL(LinearLearner - Orange.classification.svm.LinearLearner, Learner, "([examples] -/-> Classifier)") 
     1255C_NAMED(LinearClassifier - Orange.classification.svm.LinearClassifier, ClassifierFD, " ") 
    12561256 
    12571257 
     
    12891289 
    12901290#include "svm.hpp" 
    1291 C_CALL(SVMLearner, Learner, "([examples] -/-> Classifier)") 
    1292 C_CALL(SVMLearnerSparse, SVMLearner, "([examples] -/-> Classifier)") 
    1293 C_NAMED(SVMClassifier, ClassifierFD," ") 
    1294 C_NAMED(SVMClassifierSparse, SVMClassifier," ") 
     1291C_CALL(SVMLearner - Orange.core.SVMLearner, Learner, "([examples] -/-> Classifier)") 
     1292C_CALL(SVMLearnerSparse - Orange.core.SVMLearnerSparse, SVMLearner, "([examples] -/-> Classifier)") 
     1293C_NAMED(SVMClassifier - Orange.classification.svm.SVMClassifier, ClassifierFD," ") 
     1294C_NAMED(SVMClassifierSparse - Orange.classification.svm.SVMClassifierSparse, SVMClassifier," ") 
    12951295 
    12961296PyObject *SVMLearner_setWeights(PyObject *self, PyObject* args, PyObject *keywords) PYARGS(METH_VARARGS, "('list of tuple pairs') -> None") 
     
    13361336} 
    13371337 
    1338 PyObject *KernelFunc_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1338PyObject *KernelFunc_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.kernels.KernelFunc, "<abstract>") 
    13391339{ if (type == (PyTypeObject *)&PyOrKernelFunc_Type) 
    13401340    return setCallbackFunction(WrapNewOrange(mlnew TKernelFunc_Python(), type), args); 
     
    15021502 
    15031503#include "bayes.hpp" 
    1504 C_CALL(BayesLearner, Learner, "([examples], [weight=, estimate=] -/-> Classifier") 
    1505 C_NAMED(BayesClassifier, ClassifierFD, "([probabilities=])") 
     1504C_CALL(BayesLearner - Orange.core.BayesLearner, Learner, "([examples], [weight=, estimate=] -/-> Classifier") 
     1505C_NAMED(BayesClassifier - Orange.core.BayesClassifier, ClassifierFD, "([probabilities=])") 
    15061506 
    15071507PyObject *BayesClassifier_p(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(class, example) -> float") 
     
    15271527#include "rulelearner.hpp" 
    15281528 
    1529 C_NAMED(Rule, Orange, "()") 
    1530  
    1531 C_NAMED(RuleValidator_LRS, RuleValidator, "([alpha=0.05,min_coverage=0,max_rule_complexity=0,min_quality=numeric_limits<float>::min()])") 
    1532  
    1533 C_NAMED(RuleEvaluator_Entropy, RuleEvaluator, "()") 
    1534 C_NAMED(RuleEvaluator_Laplace, RuleEvaluator, "()") 
    1535 C_NAMED(RuleEvaluator_LRS, RuleEvaluator, "()") 
    1536 C_NAMED(RuleEvaluator_mEVC, RuleEvaluator, "(ruleAlpha=1.0,attributeAlpha=1.0)") 
     1529C_NAMED(Rule - Orange.classification.rules.Rule, Orange, "()") 
     1530 
     1531C_NAMED(RuleValidator_LRS - Orange.classification.rules.RuleValidator_LRS, RuleValidator, "([alpha=0.05,min_coverage=0,max_rule_complexity=0,min_quality=numeric_limits<float>::min()])") 
     1532 
     1533C_NAMED(RuleEvaluator_Entropy - Orange.classification.rules.RuleEvaluator_Entropy, RuleEvaluator, "()") 
     1534C_NAMED(RuleEvaluator_Laplace - Orange.classification.rules.RuleEvaluator_Laplace, RuleEvaluator, "()") 
     1535C_NAMED(RuleEvaluator_LRS - Orange.classification.rules.RuleEvaluator_LRS, RuleEvaluator, "()") 
     1536C_NAMED(RuleEvaluator_mEVC - Orange.classification.rules.RuleEvaluator_mEVC, RuleEvaluator, "(ruleAlpha=1.0,attributeAlpha=1.0)") 
    15371537 
    15381538C_NAMED(EVDist, Orange, "()") 
    15391539C_NAMED(EVDistGetter_Standard, EVDistGetter, "()") 
    15401540 
    1541 C_NAMED(RuleBeamFinder, RuleFinder, "([validator=, evaluator=, initializer=, refiner=, candidateSelector=, ruleFilter=])") 
    1542  
    1543 C_NAMED(RuleBeamInitializer_Default, RuleBeamInitializer, "()") 
    1544  
    1545 C_NAMED(RuleBeamRefiner_Selector, RuleBeamRefiner, "([discretization=])") 
    1546  
    1547 C_NAMED(RuleBeamCandidateSelector_TakeAll, RuleBeamCandidateSelector, "()") 
    1548  
    1549 C_NAMED(RuleBeamFilter_Width, RuleBeamFilter, "([width=5])") 
    1550  
    1551 C_NAMED(RuleDataStoppingCriteria_NoPositives, RuleDataStoppingCriteria, "()") 
    1552  
    1553 C_NAMED(RuleCovererAndRemover_Default, RuleCovererAndRemover, "()") 
    1554  
    1555 C_NAMED(RuleStoppingCriteria_NegativeDistribution, RuleStoppingCriteria, "()") 
    1556 C_CALL(RuleLearner, Learner, "([examples[, weightID]]) -/-> Classifier") 
    1557  
    1558 ABSTRACT(RuleClassifier, Classifier) 
    1559 C_NAMED(RuleClassifier_firstRule, RuleClassifier, "([rules,examples[,weightID]])") 
    1560 C_NAMED(RuleClassifier_logit, RuleClassifier, "([rules,minSig,minBeta,examples[,weightID]])") 
     1541C_NAMED(RuleBeamFinder - Orange.classification.rules.RuleBeamFinder, RuleFinder, "([validator=, evaluator=, initializer=, refiner=, candidateSelector=, ruleFilter=])") 
     1542 
     1543C_NAMED(RuleBeamInitializer_Default - Orange.classification.rules.RuleBeamInitializer_Default, RuleBeamInitializer, "()") 
     1544 
     1545C_NAMED(RuleBeamRefiner_Selector - Orange.classification.rules.RuleBeamRefiner_Selector, RuleBeamRefiner, "([discretization=])") 
     1546 
     1547C_NAMED(RuleBeamCandidateSelector_TakeAll - Orange.classification.rules.RuleBeamCandidateSelector_TakeAll, RuleBeamCandidateSelector, "()") 
     1548 
     1549C_NAMED(RuleBeamFilter_Width - Orange.classification.rules.RuleBeamFilter_Width, RuleBeamFilter, "([width=5])") 
     1550 
     1551C_NAMED(RuleDataStoppingCriteria_NoPositives - Orange.classification.rules.RuleDataStoppingCriteria_NoPositives, RuleDataStoppingCriteria, "()") 
     1552 
     1553C_NAMED(RuleCovererAndRemover_Default - Orange.classification.rules.RuleCovererAndRemover_Default, RuleCovererAndRemover, "()") 
     1554 
     1555C_NAMED(RuleStoppingCriteria_NegativeDistribution - Orange.classification.rules.RuleStoppingCriteria_NegativeDistribution, RuleStoppingCriteria, "()") 
     1556C_CALL(RuleLearner - Orange.classification.rules.RuleLearner, Learner, "([examples[, weightID]]) -/-> Classifier") 
     1557 
     1558ABSTRACT(RuleClassifier - Orange.classification.rules.RuleClassifier, Classifier) 
     1559C_NAMED(RuleClassifier_firstRule - Orange.classification.rules.RuleClassifier_firstRule, RuleClassifier, "([rules,examples[,weightID]])") 
     1560C_NAMED(RuleClassifier_logit - Orange.classification.rules.RuleClassifier_logit, RuleClassifier, "([rules,minSig,minBeta,examples[,weightID]])") 
    15611561 
    15621562PyObject *Rule_call(PyObject *self, PyObject *args, PyObject *keywords) 
     
    15991599} 
    16001600 
    1601 PyObject *RuleEvaluator_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1601PyObject *RuleEvaluator_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleEvaluator, "<abstract>") 
    16021602{ if (type == (PyTypeObject *)&PyOrRuleEvaluator_Type) 
    16031603    return setCallbackFunction(WrapNewOrange(mlnew TRuleEvaluator_Python(), type), args); 
     
    16631663} 
    16641664 
    1665 PyObject *RuleValidator_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1665PyObject *RuleValidator_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleValidator, "<abstract>") 
    16661666{ if (type == (PyTypeObject *)&PyOrRuleValidator_Type) 
    16671667    return setCallbackFunction(WrapNewOrange(mlnew TRuleValidator_Python(), type), args); 
     
    16981698} 
    16991699 
    1700 PyObject *RuleCovererAndRemover_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1700PyObject *RuleCovererAndRemover_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleCovererAndRemover, "<abstract>") 
    17011701{ if (type == (PyTypeObject *)&PyOrRuleCovererAndRemover_Type) 
    17021702    return setCallbackFunction(WrapNewOrange(mlnew TRuleCovererAndRemover_Python(), type), args); 
     
    17311731} 
    17321732 
    1733 PyObject *RuleStoppingCriteria_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1733PyObject *RuleStoppingCriteria_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleStoppingCriteria, "<abstract>") 
    17341734{ if (type == (PyTypeObject *)&PyOrRuleStoppingCriteria_Type) 
    17351735    return setCallbackFunction(WrapNewOrange(mlnew TRuleStoppingCriteria_Python(), type), args); 
     
    17631763} 
    17641764 
    1765 PyObject *RuleDataStoppingCriteria_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1765PyObject *RuleDataStoppingCriteria_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleDataStoppingCriteria, "<abstract>") 
    17661766{ if (type == (PyTypeObject *)&PyOrRuleDataStoppingCriteria_Type) 
    17671767    return setCallbackFunction(WrapNewOrange(mlnew TRuleDataStoppingCriteria_Python(), type), args); 
     
    17941794} 
    17951795 
    1796 PyObject *RuleFinder_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1796PyObject *RuleFinder_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleFinder, "<abstract>") 
    17971797{ if (type == (PyTypeObject *)&PyOrRuleFinder_Type) 
    17981798    return setCallbackFunction(WrapNewOrange(mlnew TRuleFinder_Python(), type), args); 
     
    18261826} 
    18271827 
    1828 PyObject *RuleBeamRefiner_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1828PyObject *RuleBeamRefiner_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleBeamRefiner, "<abstract>") 
    18291829{ if (type == (PyTypeObject *)&PyOrRuleBeamRefiner_Type) 
    18301830    return setCallbackFunction(WrapNewOrange(mlnew TRuleBeamRefiner_Python(), type), args); 
     
    18581858} 
    18591859 
    1860 PyObject *RuleBeamInitializer_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1860PyObject *RuleBeamInitializer_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleBeamInitializer, "<abstract>") 
    18611861{ if (type == (PyTypeObject *)&PyOrRuleBeamInitializer_Type) 
    18621862    return setCallbackFunction(WrapNewOrange(mlnew TRuleBeamInitializer_Python(), type), args); 
     
    18941894} 
    18951895 
    1896 PyObject *RuleBeamCandidateSelector_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1896PyObject *RuleBeamCandidateSelector_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleBeamCandidateSelector, "<abstract>") 
    18971897{ if (type == (PyTypeObject *)&PyOrRuleBeamCandidateSelector_Type) 
    18981898    return setCallbackFunction(WrapNewOrange(mlnew TRuleBeamCandidateSelector_Python(), type), args); 
     
    19261926} 
    19271927 
    1928 PyObject *RuleBeamFilter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1928PyObject *RuleBeamFilter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleBeamFilter, "<abstract>") 
    19291929{ if (type == (PyTypeObject *)&PyOrRuleBeamFilter_Type) 
    19301930    return setCallbackFunction(WrapNewOrange(mlnew TRuleBeamFilter_Python(), type), args); 
     
    19571957} 
    19581958 
    1959 PyObject *RuleClassifierConstructor_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>") 
     1959PyObject *RuleClassifierConstructor_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange - Orange.classification.rules.RuleClassifierConstructor, "<abstract>") 
    19601960{ if (type == (PyTypeObject *)&PyOrRuleClassifierConstructor_Type) 
    19611961    return setCallbackFunction(WrapNewOrange(mlnew TRuleClassifierConstructor_Python(), type), args); 
Note: See TracChangeset for help on using the changeset viewer.