lib_components.cpp

orange源码 数据挖掘技术

{
  return ContingencyReduceCommon(self, "__pickleLoaderContingency");
}

PyObject *__pickleLoaderContingency(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(list of PDistribution, [packed_floats])")
{ 
  return __pickleLoaderContingencyCommon(new TContingency(), args);
}


PyObject *ContingencyAttrClass__reduce__(PyObject *self, const char *loaderFunc)
{
  return ContingencyReduceCommon(self, "__pickleLoaderContingencyAttrClass");
}

PyObject *__pickleLoaderContingencyAttrClass(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(list of PDistribution, [packed_floats])")
{
  return __pickleLoaderContingencyCommon(new TContingencyAttrClass(), args);
}


PyObject *ContingencyClassAttr__reduce__(PyObject *self, const char *loaderFunc)
{
  return ContingencyReduceCommon(self, "__pickleLoaderContingencyClassAttr");
}

PyObject *__pickleLoaderContingencyClassAttr(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(list of PDistribution, [packed_floats])")
{
  return __pickleLoaderContingencyCommon(new TContingencyClassAttr(), args);
}


PyObject *ContingencyAttrAttr__reduce__(PyObject *self, const char *loaderFunc)
{
  return ContingencyReduceCommon(self, "__pickleLoaderContingencyAttrAttr");
}

PyObject *__pickleLoaderContingencyAttrAttr(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(list of PDistribution, [packed_floats])")
{
  return __pickleLoaderContingencyCommon(new TContingencyAttrAttr(), args);
}



PyObject *Contingency_add(PyObject *self, PyObject *args)  PYARGS(METH_VARARGS, "(outer_value, inner_value[, w=1]) -> None")
{
  PyTRY
    PyObject *pyouter, *pyinner;
    float w = 1.0;
    if (!PyArg_ParseTuple(args, "OO|f:Contingency.add", &pyouter, &pyinner, &w))
      return PYNULL;

   CAST_TO(TContingency, cont)

   TValue inval, outval;
    if (   !convertFromPython(pyinner, inval, cont->innerVariable)
        || !convertFromPython(pyouter, outval, cont->outerVariable))
      return PYNULL;

    cont->add(outval, inval, w);
    RETURN_NONE;
  PyCATCH
}


bool ContingencyClass_getValuePair(TContingencyClass *cont, PyObject *pyattr, PyObject *pyclass, TValue &attrval, TValue &classval)
{
  return    convertFromPython(pyattr, attrval, cont->getAttribute())
         && convertFromPython(pyclass, classval, cont->getClassVar());
}


bool ContingencyClass_getValuePair(TContingencyClass *cont, PyObject *args, char *s, TValue &attrval, TValue &classval)
{
  PyObject *pyattr, *pyclass;
  return    PyArg_ParseTuple(args, s, &pyattr, &pyclass)
         && ContingencyClass_getValuePair(cont, pyattr, pyclass, attrval, classval);
}


PyObject *ContingencyClass_add_attrclass(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(attribute_value, class_value[, w=1]) -> None")
{
  PyTRY
    CAST_TO(TContingencyClass, cont)

    PyObject *pyattr, *pyclass;
    TValue attrval, classval;
    float w = 1.0;
    if (   !PyArg_ParseTuple(args, "OO|f:ContingencyClass.add_attrclass", &pyattr, &pyclass, &w)
        || !ContingencyClass_getValuePair(cont, pyattr, pyclass, attrval, classval))
      return PYNULL;

    cont->add_attrclass(attrval, classval, w);
    RETURN_NONE;
  PyCATCH
}


PyObject *ContingencyClass_get_classVar(PyObject *self)
{
  return WrapOrange(SELF_AS(TContingencyClass).getClassVar());
}


PyObject *ContingencyClass_get_variable(PyObject *self)
{
  return WrapOrange(SELF_AS(TContingencyClass).getAttribute());
}


PyObject *ContingencyAttrClass_new(PyTypeObject *type, PyObject *args, PyObject *keywds) BASED_ON(ContingencyClass, "(attribute, class attribute) | (attribute, examples[, weightID])")
{ PyTRY
    PVariable var1, var2;
    if (PyArg_ParseTuple(args, "O&O&:Contingency.__new__", cc_Variable, &var1, cc_Variable, &var2))
      return WrapNewOrange(mlnew TContingencyAttrClass(var1, var2), type);

    PyErr_Clear();

    PyObject *object1;
    PExampleGenerator gen;
    int weightID=0;
    if (PyArg_ParseTuple(args, "OO&|O&", &object1, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID)) {
      if (PyOrVariable_Check(object1))
        return WrapNewOrange(mlnew TContingencyAttrClass(gen, PyOrange_AsVariable(object1), weightID), type);

      int attrNo;
      if (varNumFromVarDom(object1, gen->domain, attrNo))
        return WrapNewOrange(mlnew TContingencyAttrClass(gen, attrNo, weightID), type);
    }
          
    PYERROR(PyExc_TypeError, "invalid type for ContingencyAttrClass constructor", PYNULL);   

  PyCATCH
}


PyObject *ContingencyAttrClass_p_class(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(attr_value[, class_value]) -> p | distribution of classes")
{
  PyTRY
    CAST_TO(TContingencyClass, cont);

    if (PyTuple_Size(args) == 1) {
      TValue attrval;
      if (!convertFromPython(PyTuple_GET_ITEM(args, 0), attrval, cont->outerVariable))
        return PYNULL;

      PDistribution dist = CLONE(TDistribution, cont->p_classes(attrval));
      if (!dist)
        PYERROR(PyExc_AttributeError, "no distribution", PYNULL);

      dist->normalize();
      return WrapOrange(dist);
    }

    else {
      TValue attrval, classval;
      if (!ContingencyClass_getValuePair(cont, args, "OO:ContingencyAttrClass.p_class", attrval, classval))
        return PYNULL;

      return PyFloat_FromDouble(cont->p_class(attrval, classval));
    }
  PyCATCH
}


PyObject *ContingencyClassAttr_new(PyTypeObject *type, PyObject *args, PyObject *keywds) BASED_ON(ContingencyClass, "(attribute, class attribute) | (attribute, examples[, weightID])")
{ PyTRY
    PVariable var1, var2;
    if (PyArg_ParseTuple(args, "O&O&:Contingency.__new__", cc_Variable, &var1, cc_Variable, &var2))
      return WrapNewOrange(mlnew TContingencyClassAttr(var1, var2), type);

    PyErr_Clear();

    PyObject *object1;
    int weightID=0;
    PExampleGenerator gen;
    if (   PyArg_ParseTuple(args, "OO&|O&", &object1, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID)) {
      if (PyOrVariable_Check(object1))
        return WrapNewOrange(mlnew TContingencyClassAttr(gen, PyOrange_AsVariable(object1), weightID), type);
      else {
        int attrNo;
        if (varNumFromVarDom(object1, gen->domain, attrNo))
          return WrapNewOrange(mlnew TContingencyClassAttr(gen, attrNo, weightID), type);
      }
    }
          
  PyCATCH

  PYERROR(PyExc_TypeError, "invalid type for ContingencyClassAttr constructor", PYNULL);   
}


PyObject *ContingencyClassAttr_p_attr(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "([attr_value, ]class_value) -> p | distribution of values")
{
  PyTRY
    CAST_TO(TContingencyClass, cont);

    if (PyTuple_Size(args) == 1) {
      TValue classval;
      if (!convertFromPython(PyTuple_GET_ITEM(args, 0), classval, cont->outerVariable))
        return PYNULL;

      PDistribution dist = CLONE(TDistribution, cont->p_attrs(classval));
      if (!dist)
        PYERROR(PyExc_AttributeError, "no distribution", PYNULL);

      dist->normalize();
      return WrapOrange(dist);
    }

    else {
      TValue attrval, classval;
      if (!ContingencyClass_getValuePair(cont, args, "OO:ContingencyClassAttr.p_attr", attrval, classval))
        return PYNULL;

      return PyFloat_FromDouble(cont->p_attr(attrval, classval));
    }
  PyCATCH
}


PyObject *ContingencyAttrAttr_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(Contingency, "(outer_attr, inner_attr[, examples [, weight-id]])")
{ PyTRY
    PyObject *pyvar, *pyinvar;
    PExampleGenerator gen;
    int weightID=0;
    if (PyArg_ParseTuple(args, "OO|O&O&", &pyvar, &pyinvar, &pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID))
      if (gen)
        return WrapNewOrange(mlnew TContingencyAttrAttr(
           varFromArg_byDomain(pyvar, gen->domain),
           varFromArg_byDomain(pyinvar, gen->domain),
           gen, weightID), type);

      else
        if (PyOrVariable_Check(pyvar) && PyOrVariable_Check(pyinvar))
          return WrapNewOrange(mlnew TContingencyAttrAttr(
            PyOrange_AsVariable(pyvar),
            PyOrange_AsVariable(pyinvar)),
            type);
  PyCATCH

  PYERROR(PyExc_TypeError, "ContingencyAttrAttr: two variables and (opt) examples and (opt) weight expected", PYNULL);
}



PyObject *ContingencyAttrAttr_p_attr(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(outer_value[, inner_value]) -> p | distribution of values")
{
  PyTRY
    CAST_TO(TContingencyAttrAttr, cont);

    PyObject *pyouter, *pyinner = PYNULL;
    TValue outerval, innerval;
    if (   !PyArg_ParseTuple(args, "O|O:ContingencyAttrAttr.p_attr", &pyouter, &pyinner)
        || !convertFromPython(pyouter, outerval, cont->outerVariable))
      return PYNULL;

    if (!pyinner) {
      PDistribution dist = CLONE(TDistribution, cont->p_attrs(outerval));
      if (!dist)
        PYERROR(PyExc_AttributeError, "no distribution", PYNULL);

      dist->normalize();
      return WrapOrange(dist);
    }

    else {
      if (!convertFromPython(pyinner, innerval, cont->innerVariable))
        return PYNULL;

      return PyFloat_FromDouble(cont->p_attr(outerval, innerval));
    }
  PyCATCH
}


PyObject *Contingency_normalize(PyObject *self, PyObject *) PYARGS(0,"() -> None")
{ PyTRY
    SELF_AS(TContingency).normalize();
    RETURN_NONE
  PyCATCH
}


PyObject *Contingency_getitem(PyObject *self, PyObject *index)
{ PyTRY
    PDistribution *dist=Contingency_getItemRef(self, index);
    if (!dist)
      return PYNULL;

    return WrapOrange(POrange(*dist));
  PyCATCH
}


PyObject *Contingency_getitem_sq(PyObject *self, int ind)
{ PyTRY
    CAST_TO(TContingency, cont)

    if (cont->outerVariable->varType!=TValue::INTVAR)
      PYERROR(PyExc_TypeError, "cannot iterate through contingency of continuous attribute", PYNULL);

    if ((ind<0) || (ind>=int(cont->discrete->size())))
      PYERROR(PyExc_IndexError, "index out of range", PYNULL);

    return WrapOrange(POrange(cont->discrete->at(ind)));
  PyCATCH
}


int Contingency_setitem(PyObject *self, PyObject *index, PyObject *item)
{ PyTRY
    if (!PyOrDistribution_Check(item))
      PYERROR(PyExc_TypeError, "Distribution expected", -1);

    PDistribution *dist=Contingency_getItemRef(self, index);
    if (!dist)
      return -1;