lib_components.cpp

orange源码 数据挖掘技术

    PVariable var = varFromArg_byDomain(pyvar, egen->domain, false);
    if (!var)
      return NULL;

    return WrapNewOrange(mlnew TBasicAttrStat(egen, var, weightID), type);
  PyCATCH
}


PyObject *BasicAttrStat_add(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(value[, weight]) -> None")
{ PyTRY
    float value, weight=1.0;
    if (!PyArg_ParseTuple(args, "f|f:BasicAttrStat.add", &value, &weight))
      return PYNULL;
    SELF_AS(TBasicAttrStat).add(value, weight);
    RETURN_NONE;
  PyCATCH
}


PyObject *BasicAttrStat_recompute(PyObject *self) PYARGS(METH_NOARGS, "() -> None")
{ PyTRY
    SELF_AS(TBasicAttrStat).recompute();
    RETURN_NONE;
  PyCATCH
}


PyObject *BasicAttrStat_reset(PyObject *self) PYARGS(METH_NOARGS, "() -> None")
{ PyTRY
    SELF_AS(TBasicAttrStat).reset();
    RETURN_NONE;
  PyCATCH
}


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

PDomainBasicAttrStat PDomainBasicAttrStat_FromArguments(PyObject *arg) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::P_FromArguments(arg); }
PyObject *DomainBasicAttrStat_FromArguments(PyTypeObject *type, PyObject *arg) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_FromArguments(type, arg); }
PyObject *DomainBasicAttrStat_getitem_sq(TPyOrange *self, int index) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_getitem(self, index); }
int       DomainBasicAttrStat_setitem_sq(TPyOrange *self, int index, PyObject *item) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_setitem(self, index, item); }
PyObject *DomainBasicAttrStat_getslice(TPyOrange *self, int start, int stop) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_getslice(self, start, stop); }
int       DomainBasicAttrStat_setslice(TPyOrange *self, int start, int stop, PyObject *item) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_setslice(self, start, stop, item); }
int       DomainBasicAttrStat_len_sq(TPyOrange *self) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_len(self); }
PyObject *DomainBasicAttrStat_richcmp(TPyOrange *self, PyObject *object, int op) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_richcmp(self, object, op); }
PyObject *DomainBasicAttrStat_concat(TPyOrange *self, PyObject *obj) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_concat(self, obj); }
PyObject *DomainBasicAttrStat_repeat(TPyOrange *self, int times) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_repeat(self, times); }
PyObject *DomainBasicAttrStat_str(TPyOrange *self) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_str(self); }
PyObject *DomainBasicAttrStat_repr(TPyOrange *self) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_str(self); }
int       DomainBasicAttrStat_contains(TPyOrange *self, PyObject *obj) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_contains(self, obj); }
PyObject *DomainBasicAttrStat_append(TPyOrange *self, PyObject *item) PYARGS(METH_O, "(BasicAttrStat) -> None") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_append(self, item); }
PyObject *DomainBasicAttrStat_extend(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(sequence) -> None") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_extend(self, obj); }
PyObject *DomainBasicAttrStat_count(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(BasicAttrStat) -> int") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_count(self, obj); }
PyObject *DomainBasicAttrStat_filter(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "([filter-function]) -> DomainBasicAttrStat") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_filter(self, args); }
PyObject *DomainBasicAttrStat_index(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(BasicAttrStat) -> int") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_index(self, obj); }
PyObject *DomainBasicAttrStat_insert(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(index, item) -> None") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_insert(self, args); }
PyObject *DomainBasicAttrStat_native(TPyOrange *self) PYARGS(METH_NOARGS, "() -> list") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_native(self); }
PyObject *DomainBasicAttrStat_pop(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "() -> BasicAttrStat") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_pop(self, args); }
PyObject *DomainBasicAttrStat_remove(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(BasicAttrStat) -> None") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_remove(self, obj); }
PyObject *DomainBasicAttrStat_reverse(TPyOrange *self) PYARGS(METH_NOARGS, "() -> None") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_reverse(self); }
PyObject *DomainBasicAttrStat_sort(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "([cmp-func]) -> None") { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_sort(self, args); }
PyObject *DomainBasicAttrStat__reduce__(TPyOrange *self, PyObject *) { return ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_reduce(self); }


/* Note that this is not like callable-constructors. They return different type when given
   parameters, while this one returns the same type, disregarding whether it was given examples or not.
*/
PyObject *DomainBasicAttrStat_new(PyTypeObject *type, PyObject *args, PyObject *keywds) BASED_ON(Orange, "(examples | <list of BasicAttrStat>) -> DomainBasicAttrStat") ALLOWS_EMPTY
{ PyTRY
    if (!args || !PyTuple_Size(args))
      return WrapNewOrange(mlnew TDomainBasicAttrStat(), type);

    int weightID;
    PExampleGenerator gen = exampleGenFromArgs(args, weightID);
    if (gen)
      return WrapNewOrange(mlnew TDomainBasicAttrStat(gen, weightID), type);

    PyErr_Clear();

    PyObject *obj = ListOfWrappedMethods<PDomainBasicAttrStat, TDomainBasicAttrStat, PBasicAttrStat, &PyOrBasicAttrStat_Type>::_new(type, args, keywds);
    if (obj)
      return obj;

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


PyObject *DomainBasicAttrStat_purge(PyObject *self) PYARGS(METH_NOARGS, "None -> None")
{ PyTRY
    SELF_AS(TDomainBasicAttrStat).purge();
    RETURN_NONE
  PyCATCH
}

/* We keep the sequence methods and add mapping interface */

int DomainBasicAttrStat_getItemIndex(PyObject *self, PyObject *args)
{ CAST_TO_err(TDomainBasicAttrStat, bas, -1);
  
  if (PyInt_Check(args)) {
    int i=(int)PyInt_AsLong(args);
    if ((i>=0) && (i<int(bas->size())))
      return i;
    else
      PYERROR(PyExc_IndexError, "index out of range", -1);
  }

  if (PyString_Check(args)) {
    char *s=PyString_AsString(args);
    PITERATE(TDomainBasicAttrStat, ci, bas)
      if (*ci && (*ci)->variable && ((*ci)->variable->name==s))
        return ci - bas->begin();

    PyErr_Format(PyExc_IndexError, "attribute '%s' not found", s);
    return -1;
  }

  if (PyOrVariable_Check(args)) {
    PVariable var = PyOrange_AsVariable(args);
    PITERATE(TDomainBasicAttrStat, ci, bas)
      if (*ci && (*ci)->variable && ((*ci)->variable==var))
        return ci - bas->begin();

    PyErr_Format(PyExc_IndexError, "attribute '%s' not found", var->name.length() ? var->name.c_str() : "<no name>");
    return -1;
  }

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


PyObject *DomainBasicAttrStat_getitem(PyObject *self, PyObject *args)
{ PyTRY
    int index=DomainBasicAttrStat_getItemIndex(self, args);
    if (index<0)
      return PYNULL;
    return WrapOrange(POrange(SELF_AS(TDomainBasicAttrStat).at(index)));
  PyCATCH
}


int DomainBasicAttrStat_setitem(PyObject *self, PyObject *args, PyObject *obj)
{ PyTRY
    PBasicAttrStat bas;

    if (!PyOrBasicAttrStat_Check(obj))
      PYERROR(PyExc_TypeError, "invalid BasicAttrStat object", -1);

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

    SELF_AS(TDomainBasicAttrStat)[index] = PyOrange_AsBasicAttrStat(obj);
    return 0;
  PyCATCH_1
}




/* ************ CONTINGENCY ************ */

#include "contingency.hpp"
#include "estimateprob.hpp"

ABSTRACT(ContingencyClass, Contingency)

PDistribution *Contingency_getItemRef(PyObject *self, PyObject *index)
{ CAST_TO_err(TContingency, cont, (PDistribution *)NULL);
  if (!cont->outerVariable)
    PYERROR(PyExc_SystemError, "invalid contingency (no variable)", (PDistribution *)NULL);

  if (cont->outerVariable->varType==TValue::INTVAR) {
    int ind=-1;
    if (PyInt_Check(index))
      ind=(int)PyInt_AsLong(index);
    else {
      TValue val;
      if (convertFromPython(index, val, cont->outerVariable) && !val.isSpecial()) 
        ind=int(val);
    }

    if ((ind>=0) && (ind<int(cont->discrete->size())))
      return &cont->discrete->at(ind);
  }
  else if (cont->outerVariable->varType==TValue::FLOATVAR) {
    float ind;
    if (!PyNumber_ToFloat(index, ind)) {
      TValue val;
      if (convertFromPython(index, val, cont->outerVariable) && !val.isSpecial())
        ind = float(val);
      else
        PYERROR(PyExc_IndexError, "invalid index type (float expected)", NULL);
    }

    TDistributionMap::iterator mi=cont->continuous->find(ind);
    if (mi!=cont->continuous->end())
      return &(*mi).second;

    PyErr_Format(PyExc_IndexError, "invalid index (%5.3f)", ind);
    return NULL;
  }

  PYERROR(PyExc_IndexError, "invalid index", (PDistribution *)NULL);
}


PyObject *Contingency_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(Orange, "(outer_desc, inner_desc)")
{ PyTRY
    PVariable var1, var2;
    if (!PyArg_ParseTuple(args, "O&O&:Contingency.__new__", cc_Variable, &var1, cc_Variable, &var2))
      return PYNULL;

    return WrapNewOrange(mlnew TContingency(var1, var2), type);
  PyCATCH
}


PyObject *ContingencyReduceCommon(PyObject *self, const char *loaderFunc)
{
  PyTRY
    CAST_TO(TContingency, cont);

    if (cont->varType == TValue::INTVAR) {
      PyObject *dvect = PyList_New(cont->discrete->size());
      int i = 0;
      PITERATE(TDistributionVector, di, cont->discrete)
        PyList_SetItem(dvect, i++, WrapOrange(*di));

      return Py_BuildValue("O(ON)N", getExportedFunction(loaderFunc),
                                    (PyObject *)(self->ob_type),
                                    dvect, 
                                    packOrangeDictionary(self));
    }

    else if (cont->varType == TValue::FLOATVAR) {
      PyObject *dvect = PyList_New(cont->continuous->size());
      TCharBuffer buf(1024);
      int i = 0;
      PITERATE(TDistributionMap, di, cont->continuous) {
        buf.writeFloat((*di).first);
        PyList_SetItem(dvect, i++, WrapOrange((*di).second));
      }

      return Py_BuildValue("O(ONs#)N", getExportedFunction(loaderFunc),
                                      (PyObject *)(self->ob_type),
                                      dvect, 
                                      buf.buf, buf.length(),
                                      packOrangeDictionary(self));
    }

    else
      PYERROR(PyExc_SystemError, "an instance of Contingency for this attribute type cannot be pickled", NULL);

  PyCATCH
}


PyObject *__pickleLoaderContingencyCommon(TContingency *cont, PyObject *args)
{
  PyTRY
    PyTypeObject *type;
    PyObject *dvect, *packedF = NULL;
    if (!PyArg_UnpackTuple(args, "__pickleLoaderContingency", 2, 3, &type, &dvect, &packedF)) {
      delete cont;
      return NULL;
    }

    if (packedF) {
      char *pbuf;
      int bufSize;
      if (PyString_AsStringAndSize(packedF, &pbuf, &bufSize) == -1) {
        delete cont;
        return NULL;
      }
      TCharBuffer buf(pbuf);

      cont->continuous = new TDistributionMap();
      TDistributionMap &dmap = *cont->continuous;

      for(int i = 0, e = PyList_Size(dvect); i < e; i++) {
        PyObject *dist = PyList_GetItem(dvect, i);
        if (!PyOrDistribution_Check(dist)) {
          delete cont;
          PYERROR(PyExc_TypeError, "a list of distributions expected", NULL);
        }

        dmap.insert(dmap.end(), pair<float, PDistribution>(buf.readFloat(), PyOrange_AsDistribution(dist)));
      }

      return WrapNewOrange(cont, type);
    }

    else {
      cont->discrete = new TDistributionVector();
      TDistributionVector &dvec = *cont->discrete;

      for(int i = 0, e = PyList_Size(dvect); i < e; i++) {
        PyObject *dist = PyList_GetItem(dvect, i);
        if (!PyOrDistribution_Check(dist)) {
          delete cont;
          PYERROR(PyExc_TypeError, "a list of distributions expected", NULL);
        }

        dvec.push_back(PyOrange_AsDistribution(dist));
      }

      return WrapNewOrange(cont, type);
    }

  PyCATCH
}


PyObject *Contingency__reduce__(PyObject *self, const char *loaderFunc)