lib_components.cpp

orange源码 数据挖掘技术

    *dist = CLONE(TDistribution, PyOrange_AsDistribution(item));
    return 0;
  PyCATCH_1
}

int Contingency_len(PyObject *self)
{ PyTRY
    CAST_TO_err(TContingency, cont, -1);
    if (cont->outerVariable)
      if (cont->outerVariable->varType==TValue::INTVAR)
        return cont->discrete->size();
      else if (cont->outerVariable->varType==TValue::FLOATVAR)
        return cont->continuous->size();

    return 0;
  PyCATCH_1
}


bool convertFromPython(PyObject *obj, PContingency &var, bool allowNull, PyTypeObject *type)
{ if (!type)
    type = (PyTypeObject *)&PyOrContingency_Type;
    
  if (allowNull && (!obj || (obj==Py_None))) {
    var=GCPtr<TContingency>();
    return true;
  }
  if (!type)
    type = (PyTypeObject *)FindOrangeType(typeid(TContingency));

  if (!obj || !PyObject_TypeCheck(obj, type)) {
    PyErr_Format(PyExc_TypeError, "expected '%s', got '%s'", type->tp_name, obj ? obj->ob_type->tp_name : "None");
    return false;
  }
  
  var=GCPtr<TContingency>(PyOrange_AS_Orange(obj));
  return true;
}


string convertToString(const PDistribution &);

string convertToString(const PContingency &cont)
{ if (!cont->outerVariable)
    raiseError("invalid contingency ('outerVariable' not set)");

  if (cont->outerVariable->varType==TValue::INTVAR) {
    TValue val;
    cont->outerVariable->firstValue(val);

    string res="<";
    PITERATE(TDistributionVector, di, cont->discrete) {
      if (di!=cont->discrete->begin()) res+=", ";
      string vals;
      cont->outerVariable->val2str(val,vals);
      res+="'"+vals+"': "+convertToString(*di);
      cont->outerVariable->nextValue(val);
    }
    return res+">";
  }
  else if (cont->outerVariable->varType==TValue::FLOATVAR) {
    string res="<";
    char buf[128];

    PITERATE(TDistributionMap, di, cont->continuous) {
      if (di!=cont->continuous->begin()) res+=", ";
      sprintf(buf, "%.3f: ", (*di).first);
      res+=buf+convertToString((*di).second);
    }
    return res+">";
  }

  raiseError("invalid contingency");
  return string();
}

string convertToString(const PContingencyClass &cc)
{ return convertToString((const PContingency &)cc); }

PyObject *Contingency_str(PyObject *self)
{ PyTRY
    PyObject *result = callbackOutput((PyObject *)self, NULL, NULL, "str", "repr");
    if (result)
      return result;

    return PyString_FromString(convertToString(PyOrange_AsContingency(self)).c_str());
  PyCATCH
}


PyObject *Contingency_keys(PyObject *self) PYARGS(0, "() -> [string] | [float]")
{ PyTRY
    CAST_TO(TContingency, cont);
    if (cont->outerVariable)
      if (cont->outerVariable->varType==TValue::FLOATVAR) {
        PyObject *nl=PyList_New(cont->continuous->size());
        int i=0;
        PITERATE(TDistributionMap, ci, cont->continuous)
          PyList_SetItem(nl, i++, PyFloat_FromDouble((double)(*ci).first));
        return nl;
      }
      else if (cont->outerVariable->varType==TValue::INTVAR) {
        PyObject *nl=PyList_New(cont->outerVariable->noOfValues());
        int i=0;
        PStringList vals=cont->outerVariable.AS(TEnumVariable)->values;
        PITERATE(TStringList, ii, vals)
          PyList_SetItem(nl, i++, PyString_FromString((*ii).c_str()));
        return nl;
      }

    raiseError("Invalid contingency ('outerVariable' not set)");
    return PYNULL;
  PyCATCH
}

PyObject *Contingency_values(PyObject *self) PYARGS(0, "() -> [Distribution]")
{ PyTRY
    CAST_TO(TContingency, cont);
    if (cont->outerVariable)
      if (cont->outerVariable->varType==TValue::FLOATVAR) {
        PyObject *nl=PyList_New(cont->continuous->size());
        int i=0;
        PITERATE(TDistributionMap, ci, cont->continuous)
          PyList_SetItem(nl, i++, WrapOrange((*ci).second));
        return nl;
      }
      else if (cont->outerVariable->varType==TValue::INTVAR) {
        PyObject *nl=PyList_New(cont->discrete->size());
        int i=0;
        PITERATE(TDistributionVector, ci, cont->discrete)
          PyList_SetItem(nl, i++, WrapOrange(*ci));
        return nl;
      }

    PYERROR(PyExc_AttributeError, "Invalid contingency (no variable)", PYNULL);
  PyCATCH
}

PyObject *Contingency_items(PyObject *self) PYARGS(0, "() -> [(string, Distribution)] | [(float: Distribution)]")
{ PyTRY
    CAST_TO(TContingency, cont);
    if (cont->outerVariable)
      if (cont->outerVariable->varType==TValue::FLOATVAR) {
        PyObject *nl=PyList_New(cont->continuous->size());
        int i=0;
        PITERATE(TDistributionMap, ci, cont->continuous)
          PyList_SetItem(nl, i++, 
            Py_BuildValue("fN", (double)(*ci).first, WrapOrange((*ci).second)));
        return nl;
      }
      else if (cont->outerVariable->varType==TValue::INTVAR) {
        PyObject *nl=PyList_New(cont->outerVariable->noOfValues());
        int i=0;
        TStringList::const_iterator ii(cont->outerVariable.AS(TEnumVariable)->values->begin());
        PITERATE(TDistributionVector, ci, cont->discrete)
          PyList_SetItem(nl, i++, 
            Py_BuildValue("sN", (*(ii++)).c_str(), WrapOrange(*ci)));
        return nl;
      }

    PYERROR(PyExc_AttributeError, "Invalid contingency (no variable)", PYNULL);
  PyCATCH
}



/* We redefine new (removed from below!) and add mapping methods
*/

PDomainContingency PDomainContingency_FromArguments(PyObject *arg) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::P_FromArguments(arg); }
PyObject *DomainContingency_FromArguments(PyTypeObject *type, PyObject *arg) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_FromArguments(type, arg); }
PyObject *DomainContingency_getitem_sq(TPyOrange *self, int index) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_getitem(self, index); }
int       DomainContingency_setitem_sq(TPyOrange *self, int index, PyObject *item) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_setitem(self, index, item); }
PyObject *DomainContingency_getslice(TPyOrange *self, int start, int stop) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_getslice(self, start, stop); }
int       DomainContingency_setslice(TPyOrange *self, int start, int stop, PyObject *item) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_setslice(self, start, stop, item); }
int       DomainContingency_len_sq(TPyOrange *self) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_len(self); }
PyObject *DomainContingency_richcmp(TPyOrange *self, PyObject *object, int op) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_richcmp(self, object, op); }
PyObject *DomainContingency_concat(TPyOrange *self, PyObject *obj) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_concat(self, obj); }
PyObject *DomainContingency_repeat(TPyOrange *self, int times) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_repeat(self, times); }
PyObject *DomainContingency_str(TPyOrange *self) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_str(self); }
PyObject *DomainContingency_repr(TPyOrange *self) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_str(self); }
int       DomainContingency_contains(TPyOrange *self, PyObject *obj) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_contains(self, obj); }
PyObject *DomainContingency_append(TPyOrange *self, PyObject *item) PYARGS(METH_O, "(Contingency) -> None") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_append(self, item); }
PyObject *DomainContingency_extend(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(sequence) -> None") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_extend(self, obj); }
PyObject *DomainContingency_count(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(Contingency) -> int") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_count(self, obj); }
PyObject *DomainContingency_filter(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "([filter-function]) -> DomainContingency") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_filter(self, args); }
PyObject *DomainContingency_index(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(Contingency) -> int") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_index(self, obj); }
PyObject *DomainContingency_insert(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(index, item) -> None") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_insert(self, args); }
PyObject *DomainContingency_native(TPyOrange *self) PYARGS(METH_NOARGS, "() -> list") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_native(self); }
PyObject *DomainContingency_pop(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "() -> Contingency") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_pop(self, args); }
PyObject *DomainContingency_remove(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(Contingency) -> None") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_remove(self, obj); }
PyObject *DomainContingency_reverse(TPyOrange *self) PYARGS(METH_NOARGS, "() -> None") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_reverse(self); }
PyObject *DomainContingency_sort(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "([cmp-func]) -> None") { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_sort(self, args); }
PyObject *DomainContingency__reduce__(TPyOrange *self, PyObject *) { return ListOfWrappedMethods<PDomainContingency, TDomainContingency, PContingencyClass, &PyOrContingency_Type>::_reduce(self); }


CONSTRUCTOR_KEYWORDS(DomainContingency, "classIsOuter")

PyObject *DomainContingency_new(PyTypeObject *type, PyObject *args, PyObject *keywds) BASED_ON(Orange, "(examples [, weightID] | <list of Contingency>) -> DomainContingency") ALLOWS_EMPTY
{ PyTRY
    if (!args || !PyTuple_Size(args))
      return WrapNewOrange(mlnew TDomainContingency(), type);

    int weightID;
    PExampleGenerator gen = exampleGenFromArgs(args, weightID);
    if (gen) {
      bool classOuter = false;
      if (keywds) {
        PyObject *couter = PyDict_GetItemString(keywds, "classIsOuter");
        if (couter) {
          classOuter = (PyObject_IsTrue(couter) != 0);
          Py_DECREF(couter);
        }
      }

      return WrapNewOrange(mlnew TDomainContingency(gen, weightID, classOuter), type);
    }

    PyObject *obj = ListOfWrappedMethods<PDomainContingency, TDomainContingency, PDomainContingency, &PyOrContingency_Type>::_new(type, args, keywds);
    if (obj)
      return obj;

    PyErr_Clear();
    PYERROR(PyExc_TypeError, "DomainContingency.__init__ expects examples or a list of Contingencies", PYNULL);
  PyCATCH
}


int pt_DomainContingency(PyObject *args, void *egen)
{ if (PyOrDomainContingency_Check(args)) {
    *(PDomainContingency *)(egen) = PyOrange_AsDomainContingency(args);
    return 1;
  }
  else {
    egen = NULL;
    PYERROR(PyExc_TypeError, "invalid domain contingency", 0);
  }
}


int ptn_DomainContingency(PyObject *args, void *egen)
{ 
  if (args == Py_None) {
    *(PDomainContingency *)(egen) = PDomainContingency();
    return 1;
  }
  else if (PyOrDomainContingency_Check(args)) {
    *(PDomainContingency *)(egen) = PyOrange_AsDomainContingency(args);
    return 1;
  }
  else {
    egen = NULL;
    PYERROR(PyExc_TypeError, "invalid domain contingency", 0);
  }
}



int DomainContingency_getItemIndex(PyObject *self, PyObject *args)
{ PyTRY
    CAST_TO_err(TDomainContingency, cont, -1);
  
    const bool &couter = cont->classIsOuter;

    if (PyInt_Check(args)) {
      int i=(int)PyInt_AsLong(args);
      if ((i>=0) && (i<int(cont->size())))
        return i;
      else
        PYERROR(PyExc_IndexError, "index out of range", -1);
    }

    if (PyString_Check(args)) {
      char *s=PyString_AsString(args);
      PITERATE(TDomainContingency, ci, cont)
        if (couter ? (*ci)->innerVariable && ((*ci)->innerVariable->name==s)
                   : (*ci)->outerVariable && ((*ci)->outerVariable->name==s))
          return ci - cont->begin();
      PYERROR(PyExc_IndexError, "invalid variable name", -1);
    }

    if (PyOrVariable_Check(args)) {
      PVariable var = PyOrange_AsVariable(args);
      PITERATE(TDomainContingency, ci, cont)
        if (couter ? (*ci)->innerVariable && ((*ci)->innerVariable==var)
                   : (*ci)->outerVariable && ((*ci)->outerVariable==var))
          return ci - cont->begin();
      PYERROR(PyExc_IndexError, "invalid variable", -1);
    }

    PYERROR(PyExc_TypeError, "invalid index type", -1);
  PyCATCH_1
}




PyObject *DomainContingency_getitem(PyObject *self, PyObject *args)
{ PyTRY
    int index=DomainContingency_getItemIndex(self, args);
    if (index<0)
      return PYNULL;

    return WrapOrange(POrange(SELF_AS(TDomainContingency)[index]));
  PyCATCH
}


int DomainContingency_setitem(PyObject *self, PyObject *args, PyObject *obj)
{ PyTRY
    PContingency cont;
    if (!convertFromPython(obj, cont))
      PYERROR(PyExc_TypeError, "invalid Contingency object", -1);

    int index = DomainContingency_getItemIndex(self, args);
    if (index==-1)
      return -1;

    SELF_AS(TDomainContingency)[index] = cont;