lib_preprocess.cpp

orange源码 数据挖掘技术

    PYERROR(PyExc_TypeError, "invalid type (list expected)", false);

  size = PyList_Size(l);
  float *fi = f = mlnew float[size];

  for(int s = 0; s<size; s++) {
    PyObject *flt = PyNumber_Float(PyList_GetItem(l, s));
    if (!flt) {
      PyErr_Format(PyExc_TypeError, "invalid list element at index '%i'", s);
      mldelete f;
      return false;
    }
    *fi = (float)PyFloat_AsDouble(flt);
    Py_DECREF(flt);
  }

  return true;
}


PyObject *convertToPython(const T_ExampleIMColumnNode &eicn)
{ PyObject *column=PyList_New(0);

  if (eicn.column) {
    bool discrete = dynamic_cast<TDIMColumnNode *>(eicn.column) != NULL;

    for(TIMColumnNode *node=eicn.column; node; node=node->next) {
      PyObject *pycnode = PYNULL;
      if (discrete) {
        TDIMColumnNode *dnode=dynamic_cast<TDIMColumnNode *>(node);
        pycnode=Py_BuildValue("ifN", dnode->index, dnode->nodeQuality, Float2List(dnode->distribution, dnode->noOfValues)); 
      }
      else {
        TFIMColumnNode *fnode=dynamic_cast<TFIMColumnNode *>(node);
        if (fnode)
          pycnode=Py_BuildValue("iffff", fnode->index, fnode->nodeQuality,
                                         fnode->sum, fnode->sum2, fnode->N);
      }

      if (!pycnode)
        PYERROR(PyExc_TypeError, "invalid IMColumnNode", PYNULL);

      PyList_Append(column, pycnode);
      Py_DECREF(pycnode);
    }
  }

  return Py_BuildValue("NN", Example_FromWrappedExample(eicn.example), column);
}


bool convertFromPython(PyObject *args, T_ExampleIMColumnNode &eicn)
{ PyObject *column;
  TExample *example;
  if (   !PyArg_ParseTuple(args, "O&O", ptr_Example, &example, &column)
      || !PyTuple_Check(column))
    PYERROR(PyExc_TypeError, "convertFromPython(T_ExampleIMColumnNode): invalid arguments", false);

  bool discrete = PyTuple_Size(column)==3;

  eicn.example = mlnew TExample(*example);
  eicn.column = NULL;
  TIMColumnNode **nodeptr = &eicn.column;

  for(int i=0; i<PyList_Size(column); i++) {
    PyObject *item=PyList_GetItem(column, i);
    if (discrete) {
      *nodeptr=mlnew TDIMColumnNode(0, 0);
      PyObject *distr;
      TDIMColumnNode *dimcn = dynamic_cast<TDIMColumnNode *>(*nodeptr);
      if (   !PyArg_ParseTuple(item, "ifO", &(*nodeptr)->index, &(*nodeptr)->nodeQuality, &distr)
          || !List2Float(distr, dimcn->distribution, dimcn->noOfValues)) {
        mldelete eicn.column;
        PYERROR(PyExc_TypeError, "invalid column node", false);
      }
    }
    else {
      *nodeptr=mlnew TFIMColumnNode(0);
      if (!PyArg_ParseTuple(item, "iffff", &(*nodeptr)->index, &(*nodeptr)->nodeQuality,
                                           &dynamic_cast<TFIMColumnNode *>(*nodeptr)->sum, 
                                           &dynamic_cast<TFIMColumnNode *>(*nodeptr)->sum2, 
                                           &dynamic_cast<TFIMColumnNode *>(*nodeptr)->N)) {
        mldelete eicn.column;
        PYERROR(PyExc_TypeError, "invalid column node", false);
      }
    }
  }
  return true;
}


PyObject *convertToPython(const PIM &im)
{ PyObject *result=PyList_New(0);
  const_ITERATE(vector<T_ExampleIMColumnNode>, ici, im->columns) {
    PyObject *item=convertToPython(*ici);
    if (!item) {
      PyMem_DEL(result);
      PYERROR(PyExc_SystemError, "out of memory", PYNULL);
    }
    PyList_Append(result, item);
    Py_DECREF(item);
  }
  return result;
}
      
bool convertFromPython(PyObject *args, PIM &im)
{ im=PIM();
  if (!PyList_Check(args) || !PyList_Size(args))
    PYERROR(PyExc_TypeError, "invalid incompatibility matrix", false);

  // This is just to determine the type...
  int varType = -1;
  T_ExampleIMColumnNode testcolumn;
  if (!convertFromPython(PyList_GetItem(args, 0), testcolumn))
    return false;

  varType = dynamic_cast<TDIMColumnNode *>(testcolumn.column) ? TValue::INTVAR : TValue::FLOATVAR;
  const type_info &tinfo = typeid(*testcolumn.column);

  im=PIM(mlnew TIM(varType));
  im->columns=vector<T_ExampleIMColumnNode>();
  for(int i=0; i<PyList_Size(args); i++) {
    PyObject *item=PyList_GetItem(args, i);
    im->columns.push_back(T_ExampleIMColumnNode());
    if (!convertFromPython(item, im->columns.back())) {
      im=PIM();
      return false;
    }
    if (tinfo == typeid(im->columns.back().column))
      PYERROR(PyExc_TypeError, "invalid incompatibility matrix (mixed discrete and continuous classes)", false)
  }

  return true;
}


PyObject *IM_native(PyObject *self) PYARGS(0, "() -> [[index, quality, distribution, c]] | [[index, quality, sum, sum2, N]]")
{ PyTRY
    return convertToPython(PyOrange_AsIM(self)); 
  PyCATCH
}

PyObject *IM_fuzzy(PyObject *self) PYARGS(0, "() -> boolean")
{ PyTRY
    return PyInt_FromLong(SELF_AS(TIM).fuzzy() ? 1L : 0L); 
  PyCATCH
}


PyObject *IM_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(Orange, "<see the manual>")
{ PyTRY
    PIM im;
    PyObject *pyim;
    return PyArg_ParseTuple(args, "O:IM.new", &pyim) && convertFromPython(pyim, im) ? WrapOrange(im) : PYNULL;
  PyCATCH
}


PyObject *IM__reduce__(PyObject *self)
{
  PyTRY
    return Py_BuildValue("O(N)N", self->ob_type, IM_native(self), packOrangeDictionary(self));
  PyCATCH
}


PyObject *convertToPython(const TDIMRow &row)
{ PyObject *pyrow=PyList_New(row.nodes.size());
  int i = 0;
  const int &noval = row.noOfValues;
  const_ITERATE(vector<float *>, ii, row.nodes)
    PyList_SetItem(pyrow, i++, Float2List(*ii, noval));

  return Py_BuildValue("NN", Example_FromWrappedExample(row.example), pyrow);
}


PyObject *convertToPython(const PIMByRows &im)
{ PyObject *result=PyList_New(im->rows.size());
  int i=0;
  const_ITERATE(vector<TDIMRow>, ri, im->rows)
    PyList_SetItem(result, i++, convertToPython(*ri));
  return result;  
}

PyObject *IMByRows_native(PyObject *self) PYARGS(0, "() -> [example, [distributions]]")
{ PyTRY
    return convertToPython(PyOrange_AsIMByRows(self));
  PyCATCH
}

PyObject *IMByRows_get_columnExamples(PyObject *self) PYDOC("Values of bound attributes for each column")
{ PyTRY
    CAST_TO(TIMByRows, pimr);
    PyObject *result=PyList_New(pimr->columnExamples.size());
    int i=0;
    ITERATE(vector<PExample>, ei, pimr->columnExamples)
      PyList_SetItem(result, i++, Example_FromWrappedExample(*ei));
    return result;
  PyCATCH
}

PyObject *ClustersFromIM_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(im) -> IMClustering")
{ 
  PyTRY
    NO_KEYWORDS

    PIM im;
    if (!PyArg_ParseTuple(args, "O&:ClustersFromIM.__call__", cc_IM, &im))
      return PYNULL;

    return WrapOrange(SELF_AS(TClustersFromIM)(im));
  PyCATCH
}





PyObject *AssessIMQuality_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(im) -> float")
{ 
  PyTRY
    NO_KEYWORDS

    PIM im;
    if (!PyArg_ParseTuple(args, "O&:AssessIMQuality.__call__", cc_IM, &im))
      return PYNULL;

    return PyFloat_FromDouble((double)SELF_AS(TAssessIMQuality)(im));
  PyCATCH
}



/* ************ FEATURE CONSTRUCTION BY CLUSTERING ******** */

#include "dist_clustering.hpp"

ABSTRACT(ExampleDistConstructor, Orange)
C_CALL(ExampleDistBySorting, ExampleDistConstructor, "([examples, bound-attrs[, weightID]]) -/-> ExampleDistVector")
BASED_ON(ExampleDistVector, Orange)
ABSTRACT(ClustersFromDistributions, Orange)
C_CALL(ClustersFromDistributionsByAssessor, ClustersFromDistributions, "([example-dist-vector] [minProfitProportion=, distributionAssessor=, stopCriterion=]) -/-> DistClustering")
C_CALL(FeatureByDistributions, FeatureInducer, "() | ([examples, bound-attrs, name], [constructExampleDist=, completion=]) -/-> Variable")

ABSTRACT(DistributionAssessor, Orange)
C_NAMED(DistributionAssessor_Laplace, DistributionAssessor, "()")
C_NAMED(DistributionAssessor_m, DistributionAssessor, "([m=])")
C_NAMED(DistributionAssessor_mf, DistributionAssessor, "([m=])")
C_NAMED(DistributionAssessor_Relief, DistributionAssessor, "()")
C_NAMED(DistributionAssessor_Measure, DistributionAssessor, "([measure=])")
C_NAMED(DistributionAssessor_Kramer, DistributionAssessor, "()")

ABSTRACT(StopDistributionClustering, Orange)
C_NAMED(StopDistributionClustering_noProfit, StopDistributionClustering, "([minProfitProportion=])")
C_NAMED(StopDistributionClustering_binary, StopDistributionClustering, "()")
C_NAMED(StopDistributionClustering_n, StopDistributionClustering, "([n=])")
C_NAMED(StopDistributionClustering_noBigChange, StopDistributionClustering, "()")


PYCLASSCONSTANT_INT(FeatureByDistributions, NoCompletion, completion_no)
PYCLASSCONSTANT_INT(FeatureByDistributions, CompletionByDefault, completion_default)
PYCLASSCONSTANT_INT(FeatureByDistributions, CompletionByBayes, completion_bayes)


PyObject *ExampleDistConstructor_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(examples, bound-attrs[, weightID]) -> ExampleDistVector")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator egen;
    PyObject *boundList;
    int weightID=0;
    if (!PyArg_ParseTuple(args, "O&O|O&:ExampleDistConstructor.__call__", pt_ExampleGenerator, &egen, &boundList, pt_weightByGen(egen), &weightID))
      return PYNULL;

    TVarList boundset;
    if (!varListFromDomain(boundList, egen->domain, boundset))
      return PYNULL;

    PExampleDistVector edv = SELF_AS(TExampleDistConstructor)(egen, boundset, weightID);
    return WrapOrange(edv);
  PyCATCH
}





PyObject *convertToPython(const T_ExampleDist &ed)
{ return Py_BuildValue("NN", Example_FromWrappedExample(ed.example), WrapOrange(const_cast<GCPtr<TDistribution> &>(ed.distribution))); }



PyObject *convertToPython(const PExampleDistVector &edv)
{ PyObject *result=PyList_New(0);
  const_ITERATE(vector<T_ExampleDist>, ici, edv->values) {
    PyObject *item=convertToPython(*ici);
    if (!item) {
      PyMem_DEL(result);
      PYERROR(PyExc_SystemError, "out of memory", PYNULL);
    }
    PyList_Append(result, item);
    Py_DECREF(item);
  }
  return result;
}
      

PyObject *ExampleDistVector__reduce__(PyObject *self)
{
  PyTRY
    vector<T_ExampleDist> &values = SELF_AS(TExampleDistVector).values;

    PyObject *pyvalues = PyList_New(values.size() * 2);
    int i = 0;
    ITERATE(vector<T_ExampleDist>, edi, values) {
      PyList_SetItem(pyvalues, i++, Example_FromWrappedExample(edi->example));
      PyList_SetItem(pyvalues, i++, WrapOrange(edi->distribution));
    }
     
    return Py_BuildValue("O(ON)N", getExportedFunction("__pickleLoaderExampleDistVector"),
                                   self->ob_type,
                                   pyvalues,
                                   packOrangeDictionary(self));

  PyCATCH
}


PyObject *__pickleLoaderExampleDistVector(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(type, values)")
{
  PyTRY
    PyTypeObject *type;
    PyObject *pyvalues;
    if (!PyArg_ParseTuple(args, "OO:__pickleLoaderExampleDistVector", &type, &pyvalues))
      return NULL;

    TExampleDistVector *ed = new TExampleDistVector();

    try {
      int i = 0, e = PyList_Size(pyvalues);
      ed->values.reserve(e>>1);
      while(i < e) {
        PExample ex = PyExample_AS_Example(PyList_GetItem(pyvalues, i++));
        PDistribution dist = PyOrange_AsDistribution(PyList_GetItem(pyvalues, i++));
        ed->values.push_back(T_ExampleDist(ex, dist));
      }

      return WrapNewOrange(ed, type);
    }
    catch (...) {
      delete ed;
      throw;
    }
  PyCATCH
}


PyObject *ExampleDistVector_native(PyObject *self) PYARGS(0, "() -> [[[float]]] | [[{float: float}]]")
{ PyTRY
    return convertToPython(PyOrange_AsExampleDistVector(self));
  PyCATCH
}



PyObject *ClustersFromDistributions_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(example-dist-vector) -> DistClustering")
{ 
  PyTRY
    NO_KEYWORDS

    PExampleDistVector edv;
    if (!PyArg_ParseTuple(args, "O&:ClustersFromDistributions.__call__", cc_ExampleDistVector, &edv))
      return PYNULL;

    return WrapOrange(SELF_AS(TClustersFromDistributions)(edv));
  PyCATCH
}


#include "lib_preprocess.px"