lib_kernel.cpp

orange源码 数据挖掘技术

{ PyTRY
    PyObject *list;
    PyObject *arg1 = PYNULL;
    PyObject *arg2 = PYNULL;

    if (PyArg_ParseTuple(args, "O|OO", &list, &arg1, &arg2)) {

      if (keywds) {
        if (PyDict_Size(keywds)>1)
          PYERROR(PyExc_TypeError, "Domain() accepts only one keyword argument ('source')", PYNULL);
        if (PyDict_Size(keywds)==1) {
          PyObject *arg3 = PyDict_GetItemString(keywds, "source");
          if (!arg3)
            PYERROR(PyExc_TypeError, "Domain: invalid keywords argument ('source' expected)", PYNULL);
          if (arg1 && arg2) {
            PYERROR(PyExc_TypeError, "Domain: too many arguments", PYNULL);
          }
          else
            if (!arg1)
              arg1 = arg3;
            else
              arg2 = arg3;
        }
      }


      if (PyOrDomain_Check(list)) {

        PDomain dom = PyOrange_AsDomain(list);

        if (arg1)
          if (PyString_Check(arg1) || PyOrVariable_Check(arg1)) {
            PVariable classVar = varFromArg_byDomain(arg1, dom, false);
            if (!classVar)
              return PYNULL;
            TVarList attributes = dom->variables.getReference();
            int vnumint = dom->getVarNum(classVar, false);
            if (vnumint>=0)
              attributes.erase(attributes.begin()+vnumint);
            return WrapNewOrange(mlnew TDomain(classVar, attributes), type);
          }
          else if (PyInt_Check(arg1) || (arg1==Py_None)) {
            TVarList attributes = dom->variables.getReference();
            if (PyObject_IsTrue(arg1))
              return WrapNewOrange(CLONE(TDomain, dom), type);
            else
              return WrapNewOrange(mlnew TDomain(PVariable(), dom->variables.getReference()), type);
          }
          else 
            PYERROR(PyExc_TypeError, "Domain: invalid arguments for constructor (I'm unable to guess what you meant)", PYNULL);

        return WrapNewOrange(CLONE(TDomain, dom), type);
      }

      /* Now, arg1 can be either 
           - NULL
           - source (i.e. Domain or list of variables) 
           - boolean that tells whether we have a class
           - class variable
         If arg1 is present but is not source, arg2 can be source
      */

      PVarList source;
      PVariable classVar;
      bool hasClass = true;

      if (arg1) {
        if (PyOrDomain_Check(arg1))
          source = PyOrange_AsDomain(arg1)->variables;
        else if (PyOrVarList_Check(arg1))
          source = PyOrange_AsVarList(arg1);
        else if (PyList_Check(arg1))
          source = PVarList_FromArguments(arg1);
        else if (PyOrVariable_Check(arg1))
          classVar = PyOrange_AsVariable(arg1);
        else
          hasClass = (PyObject_IsTrue(arg1) != 0);
      }
      if (arg2) {
        if (source) {
          PYERROR(PyExc_TypeError, "Domain: invalid argument 3", PYNULL);
        }
        else
          if (PyOrDomain_Check(arg2)) {
            PDomain sourceDomain = PyOrange_AsDomain(arg2);
            source = mlnew TVarList(sourceDomain->variables.getReference());
            ITERATE(TMetaVector, mi, sourceDomain->metas)
              source->push_back((*mi).variable);
          }

          else if (PyOrVarList_Check(arg2))
            source = PyOrange_AsVarList(arg2);
          else if (PyList_Check(arg2))
            source = PVarList_FromArguments(arg2);
      }

      TVarList variables;
      if (!varListFromVarList(list, source, variables, true, false))
        return PYNULL;

      if (hasClass && !classVar && variables.size()) {
        classVar = variables.back();
        variables.erase(variables.end()-1);
      }
      
      return WrapNewOrange(mlnew TDomain(classVar, variables), type);
    }

    PYERROR(PyExc_TypeError, "invalid parameters (list of 'Variable' expected)", PYNULL);

  PyCATCH
}


PyObject *Domain__reduce__(PyObject *self)
{
  CAST_TO(TDomain, domain)

  
  return Py_BuildValue("O(ONNNN)N", getExportedFunction("__pickleLoaderDomain"),
                                   self->ob_type,
                                   WrapOrange(domain->attributes),
                                   WrapOrange(domain->classVar),
                                   Domain_getmetasLow(SELF_AS(TDomain), false),
                                   Domain_getmetasLow(SELF_AS(TDomain), true),
                                   packOrangeDictionary(self));
}

PyObject *__pickleLoaderDomain(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(type, attributes, classVar, metas)")
{
  PyTRY {
    if (!args || !PyTuple_Check(args) || (PyTuple_Size(args) != 5))
      PYERROR(PyExc_TypeError, "invalid arguments for the domain unpickler", NULL);

    PyTypeObject *type = (PyTypeObject *)PyTuple_GET_ITEM(args, 0);
    PyObject *attributes = PyTuple_GET_ITEM(args, 1);
    PyObject *classVar = PyTuple_GET_ITEM(args, 2);
    PyObject *req_metas = PyTuple_GET_ITEM(args, 3);
    PyObject *opt_metas = PyTuple_GET_ITEM(args, 4);

    if (!PyOrVarList_Check(attributes) || !PyDict_Check(req_metas) || !PyDict_Check(opt_metas))
      PYERROR(PyExc_TypeError, "invalid arguments for the domain unpickler", NULL);

  
    TDomain *domain = NULL;
    if (classVar == Py_None)
      domain = new TDomain(PVariable(), PyOrange_AsVarList(attributes).getReference());
    else if (PyOrVariable_Check(classVar))
      domain = new TDomain(PyOrange_AsVariable(classVar), PyOrange_AsVarList(attributes).getReference());
    else
      PYERROR(PyExc_TypeError, "invalid arguments for the domain unpickler", NULL);
      

    PyObject *pydomain = WrapNewOrange(domain, type);

    PyObject *res;
    res = Domain_addmetasLow(*domain, req_metas, false);
    if (!res) {
      Py_DECREF(pydomain);
      return NULL;
    }
    Py_DECREF(res);

    res = Domain_addmetasLow(*domain, opt_metas, true);
    if (!res) {
      Py_DECREF(pydomain);
      return NULL;
    }
    Py_DECREF(res);

    return pydomain;
  }
  PyCATCH
}


PyObject *Domain_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(example) -> Example")
{ PyTRY
    NO_KEYWORDS

    TExample *ex;
    if (!PyArg_ParseTuple(args, "O&", ptr_Example, &ex))
      PYERROR(PyExc_TypeError, "invalid parameters (Example expected)", PYNULL);

    return Example_FromWrappedExample(PExample(mlnew TExample(PyOrange_AsDomain(self), *ex)));
  PyCATCH
}


PyObject *Domain_getitem(TPyOrange *self, PyObject *index)
{ PyTRY
    PVariable var = varFromArg_byDomain(index, PyOrange_AsDomain(self), true);
    return var ? WrapOrange(var) : PYNULL;
  PyCATCH
}


PyObject *Domain_getitem_sq(TPyOrange *self, int index)
{ PyTRY
    CAST_TO(TDomain, domain)
    if ((index<0) || (index>=int(domain->variables->size())))
      PYERROR(PyExc_IndexError, "index out of range", PYNULL);
    return WrapOrange(domain->getVar(index));
  PyCATCH
}


PyObject *Domain_getslice(TPyOrange *self, int start, int stop)
{ 
  PyTRY
    CAST_TO(TDomain, domain);

    int ds=domain->variables->size();
    if (start>ds) 
      start=ds;
    else if (start<0)
      start=0;

    if (stop>ds) stop=ds;
    else if (stop<0) stop=0;
    stop-=start;
    PyObject *list=PyList_New(stop);
    if (!list)
      return NULL;
    TVarList::iterator vi(domain->variables->begin()+start);
    for(int i=0; i<stop; i++)
      PyList_SetItem(list, i, WrapOrange(*(vi++)));
    return list;
  PyCATCH
}


const string &nonamevar = string("<noname>");

inline const string &namefrom(const string &name)
{ return name.length() ? name : nonamevar; }

string TDomain2string(TPyOrange *self)
{ CAST_TO_err(TDomain, domain, "<invalid domain>")

  string res;
  
  int added=0;
  PITERATE(TVarList, vi, domain->variables)
    res+=(added++ ? ", " : "[") + namefrom((*vi)->name);

  if (added) {
    res+="]";
    if (domain->metas.size())
      res+=", {";
  }
  else 
    if (domain->metas.size())
      res+="{";

  added=0;
  ITERATE(TMetaVector, mi, domain->metas) {
    char pls[256];
    sprintf(pls, "%s%i:%s", (added++) ? ", " : "", int((*mi).id), namefrom((*mi).variable->name).c_str());
    res+=pls;
  }
  if (added)
    res+="}";

  return res;
}



PyObject *Domain_repr(TPyOrange *pex)
{ PyTRY
    PyObject *result = callbackOutput((PyObject *)pex, NULL, NULL, "repr", "str");
    if (result)
      return result;

    return PyString_FromString(TDomain2string(pex).c_str());
  PyCATCH
}


PyObject *Domain_str(TPyOrange *pex)
{ PyTRY
    PyObject *result = callbackOutput((PyObject *)pex, NULL, NULL, "str", "repr");
    if (result)
      return result;

    return PyString_FromString(TDomain2string(pex).c_str());
  PyCATCH
}


int Domain_set_classVar(PyObject *self, PyObject *arg) PYDOC("Domain's class attribute")
{
  PyTRY
    CAST_TO_err(TDomain, domain, -1);
  
    if (arg==Py_None)
      domain->removeClass();
    else
      if (PyOrVariable_Check(arg))
        domain->changeClass(PyOrange_AsVariable(arg));
      else PYERROR(PyExc_AttributeError, "invalid type for class", -1)

    return 0;
  PyCATCH_1
}



/* ************ RANDOM GENERATORS ************** */

#include "random.hpp"

C_UNNAMED(RandomGenerator, Orange, "() -> 32-bit random int")

PyObject *RandomGenerator_new(PyTypeObject *type, PyObject *args, PyObject *keywds) BASED_ON(Orange, "([int])")
{ PyTRY
      int i = 0;
      if (!PyArg_ParseTuple(args, "|i:RandomGenerator.__new__", &i))
        return PYNULL;

      return WrapNewOrange(mlnew TRandomGenerator(i), type);
  PyCATCH
}


PyObject *RandomGenerator__reduce__(PyObject *self)
{
  cMersenneTwister &mt = SELF_AS(TRandomGenerator).mt;

  return Py_BuildValue("O(Os#ii)N", getExportedFunction("__pickleLoaderRandomGenerator"),
                                    self->ob_type,
                                    (char *)(mt.state), (mt.next-mt.state + mt.left + 1) * sizeof(long),
                                    mt.next - mt.state,
                                    mt.left,
                                    packOrangeDictionary(self));
}


PyObject *__pickleLoaderRandomGenerator(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(type, state, next_offset, left)")
{
  PyTypeObject *type;
  int offs;
  int left;
  char *buff;
  int bufsize;
  if (!PyArg_ParseTuple(args, "Os#ii", &type, &buff, &bufsize, &offs, &left))
    return PYNULL;

  TRandomGenerator *rg = new TRandomGenerator;

  cMersenneTwister &mt = rg->mt;
  memcpy(mt.state, buff, bufsize);
  mt.next = mt.state + offs;
  mt.left = left;

  return WrapNewOrange(rg, type);
}


PyObject *RandomGenerator_reset(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "([new_seed]) -> None")
{ PyTRY
    int seed = numeric_limits<int>::min();
    if (!PyArg_ParseTuple(args, "|i:RandomGenerator.reset", &seed))
      return PYNULL;

    if (seed != numeric_limits<int>::min())
      SELF_AS(TRandomGenerator).initseed = seed;

    SELF_AS(TRandomGenerator).reset();
    RETURN_NONE; 
  PyCATCH
}

PyObject *RandomGenerator_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("() -> 32-bit random int")
{ PyTRY
    NO_KEYWORDS

    if (!PyArg_ParseTuple(args, ""))
      PYERROR(PyExc_TypeError, "no arguments expected", PYNULL);
    return PyInt_FromLong((long)SELF_AS(TRandomGenerator)());
  PyCATCH