cls_value.cpp

orange源码 数据挖掘技术

}


int Value_nonzero(TPyValue *i)
{ PyTRY
    return !i->value.isSpecial();
  PyCATCH_1
}


int Value_coerce(PyObject **i, PyObject **obj)
{ PyTRY
    if (PyString_Check(*obj)) {
      *i = Value_str(*(TPyValue **)i);
      if (!*i)
        return -1;
      Py_INCREF(*obj);
      return 0;
    }

    if (PyInt_Check(*obj)) {
      TPyValue *val = *(TPyValue **)i;
      if (val->value.varType==TValue::INTVAR) {
        *i = Value_int(val);
        if (!*i)
          return -1;
        Py_INCREF(*obj);
        return 0;
      }
      else if (val->value.varType==TValue::FLOATVAR) {
        *i = Value_float(val);
        if (!*i)
          return -1;
        double x = PyFloat_AsDouble(*obj);
		    *obj = PyFloat_FromDouble(x);
        return 0;
      }
      else
        return -1;
    }

    if (PyFloat_Check(*obj)) {
      *i = Value_float(*(TPyValue **)i);
      if (!*i)
        return -1;
      Py_INCREF(*obj);
      return 0;
    }

    if (PyLong_Check(*obj)) {
      *i = Value_long(*(TPyValue **)i);
      if (!*i)
        return -1;
      Py_INCREF(*obj);
      return 0;
    }

    return -1;
  PyCATCH_1
}



PyObject *Value_get_svalue(TPyValue *self)
{ PyTRY
    if (self->value.varType == PYTHONVAR) {
      PyObject *res = self->value.svalV ? ((TPythonValue &)(self->value.svalV.getReference())).value : Py_None;
      Py_INCREF(res);
      return res;
    }

    return WrapOrange(self->value.svalV);
  PyCATCH
}


int Value_set_svalue(TPyValue *self, PyObject *arg)
{ PyTRY

    if (arg == Py_None) {
      self->value.svalV = PSomeValue();
      return 0;
    }

    if (PyOrSomeValue_Check(arg)) {
      self->value.svalV = PyOrange_AsSomeValue(arg);
      return 0;
    }

    Py_INCREF(arg);
    self->value.svalV = mlnew TPythonValue(arg);
    return 0;

  PyCATCH_1
}


PyObject *Value_get_value(TPyValue *self)
{ PyTRY
    return convertToPythonNative(self);
  PyCATCH
}


int Value_set_value(TPyValue *self, PyObject *arg)
{ PyTRY
    return convertFromPython(arg, self->value, self->variable) ? 0 : -1;
  PyCATCH_1
}


PyObject *Value_get_valueType(TPyValue *self)
{ return PyInt_FromLong((long)self->value.valueType); }


PyObject *Value_get_variable(TPyValue *self)
{ return WrapOrange(self->variable); }


int Value_set_variable(TPyValue *self, PyObject *arg)
{ PyTRY
    if (arg == Py_None) {
      self->variable = PVariable();
      return 0;
    }
    if (!PyOrVariable_Check(arg))
      PYERROR(PyExc_TypeError, "invalid argument for attribute 'variable'", -1)
    else {
      self->variable = PyOrange_AsVariable(arg);
      return 0;
    }
  PyCATCH_1
}


PyObject *Value_get_varType(TPyValue *self)
{ return PyInt_FromLong((long)self->value.varType); }




PyObject *Value_randomvalue(TPyValue *self) PYARGS(METH_NOARGS, "(); Sets the value to a random")
{ PyTRY
    CHECK_VARIABLE
    self->value = self->variable->randomValue();
    RETURN_NONE
  PyCATCH
}


PyObject *Value_firstvalue(TPyValue *self)  PYARGS(METH_NOARGS, "() -> bool; Sets the value to the first value")
{ PyTRY
    CHECK_VARIABLE
    return PyInt_FromLong(self->variable->firstValue(self->value) ? 1 : 0);
  PyCATCH
}


PyObject *Value_nextvalue(TPyValue *self)  PYARGS(METH_NOARGS, "() -> bool; Increases the value (if possible)")
{ PyTRY
    CHECK_VARIABLE
    return PyInt_FromLong(self->variable->nextValue(self->value) ? 1 : 0);
  PyCATCH
}


PyObject *Value_isSpecial(TPyValue *self)  PYARGS(METH_NOARGS, "() -> bool; Returns true if value is DK, DC...")
{ return PyInt_FromLong(self->value.isSpecial() ? 1 : 0); }


PyObject *Value_isDK(TPyValue *self)  PYARGS(METH_NOARGS, "() -> bool; Returns true if value is DK")
{ return PyInt_FromLong(self->value.isDK() ? 1 : 0); }


PyObject *Value_isDC(TPyValue *self)  PYARGS(METH_NOARGS, "() -> bool; Returns true if value is DC")
{ return PyInt_FromLong(self->value.isDC() ? 1 : 0); }


PyObject *Value_native(TPyValue *self)   PYARGS(METH_NOARGS, "() -> bool; Converts the value into string or float")
{ PyTRY
    return convertToPythonNative(self);
  PyCATCH
}


#include "slist.hpp"

bool Value_pack(const TValue &value, TCharBuffer &buf, PyObject *&otherValues)
{
  const char svalFlag = value.svalV ? 1 << 5 : 0;
  if (svalFlag) {
    if (!otherValues)
      otherValues = PyList_New(0);
    PyObject *sv = WrapOrange(value.svalV);
    PyList_Append(otherValues, sv);
    Py_DECREF(sv);
  }

  if (value.valueType) {
    buf.writeChar(svalFlag | (value.valueType & 0x3f));
    return true;
  }

  if (value.varType == TValue::INTVAR) {
    if (value.intV < (1 << (sizeof(char) << 3))) {
      buf.writeChar((1 << 6) | svalFlag);
      buf.writeChar(char(value.intV));
    }

    else if (value.intV < (1 << (sizeof(short) << 3))) {
      buf.writeChar((2 << 6) | svalFlag);
      buf.writeShort((unsigned short)(value.intV));
    }

    else {
      buf.writeChar((3 << 6) | svalFlag);
      buf.writeInt(value.intV);
    }

    return true;
  }

  else if (value.varType == TValue::FLOATVAR) {
    buf.writeChar(svalFlag);
    buf.writeFloat(value.floatV);
  }

  else
    buf.writeChar(svalFlag);

  return true;
}


bool Value_unpack(TValue &value, TCharBuffer &buf, PyObject *otherValues, int &otherValuesIndex)
{
  char flags = buf.readChar();

  if (flags & (1 << 5))
    value.svalV = PyOrange_AsSomeValue(PyList_GetItem(otherValues, otherValuesIndex++));

  value.valueType = flags & 0x1f;

  if (value.valueType) {
    value.floatV = numeric_limits<float>::quiet_NaN();
    value.intV = numeric_limits<int>::max();
    return true;
  }

  if (value.varType == TValue::INTVAR) {
    flags >>= 6;
    if (flags == 1)
      value.intV = buf.readChar();
    else if (flags == 2)
      value.intV = buf.readShort();
    else if (flags == 3)
      value.intV = buf.readInt();
    value.floatV = numeric_limits<float>::quiet_NaN();
  }

  else if (value.varType == TValue::FLOATVAR) {
    value.floatV = buf.readFloat();
    value.intV = numeric_limits<int>::max();
  }
    
  return true;
}

PyObject *Value__reduce__(PyObject *self)
{
  PyTRY
    TCharBuffer buf(16);
    PyObject *otherValues = NULL;
    buf.writeChar(PyValue_AS_Value(self).varType);
    Value_pack(PyValue_AS_Value(self), buf, otherValues);
    if (!otherValues) {
      otherValues = Py_None;
      Py_INCREF(otherValues);
    }
    
    return Py_BuildValue("O(Ns#N)", getExportedFunction("__pickleLoaderValue"),
                                   WrapOrange(PyValue_AS_Variable(self)),
                                   buf.buf, buf.length(),
                                   otherValues);
  PyCATCH
}


PyObject *__pickleLoaderValue(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(variable, packed_values, other_values)")
{
  PyTRY
    PVariable var;
    char *pbuf;
    int bufSize;
    PyObject *otherValues;
    if (!PyArg_ParseTuple(args, "O&s#O:__pickleLoaderValue", ccn_Variable, &var, &pbuf, &bufSize, &otherValues))
      return PYNULL;

    TCharBuffer buf(pbuf);
    int otherValuesIndex = 0;
    TValue val((const unsigned char &)(buf.readChar()));
    Value_unpack(val, buf, otherValues, otherValuesIndex);
    return Value_FromVariableValue(var, val);
  PyCATCH
}

#undef CHECK_VARIABLE
#undef CHECK_SPECIAL_OTHER


// This is in a separate file to avoid scanning by pyxtract
#include "valuelisttemplate.hpp"

// Modified new and related stuff, removed rich_cmp (might be added later, but needs to be programmed specifically)
PValueList PValueList_FromArguments(PyObject *arg, PVariable var = PVariable())
{ return TValueListMethods::P_FromArguments(arg, var); }


PyObject *ValueList_FromArguments(PyTypeObject *type, PyObject *arg, PVariable var = PVariable())
{ return TValueListMethods::_FromArguments(type, arg, var); }


PyObject *ValueList_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange, "(<list of Value>)")  ALLOWS_EMPTY
{ return TValueListMethods::_new(type, arg, kwds); }


PyObject *ValueList_getitem_sq(TPyOrange *self, int index) { return TValueListMethods::_getitem(self, index); }
int       ValueList_setitem_sq(TPyOrange *self, int index, PyObject *item) { return TValueListMethods::_setitem(self, index, item); }
PyObject *ValueList_getslice(TPyOrange *self, int start, int stop) { return TValueListMethods::_getslice(self, start, stop); }
int       ValueList_setslice(TPyOrange *self, int start, int stop, PyObject *item) { return TValueListMethods::_setslice(self, start, stop, item); }
int       ValueList_len_sq(TPyOrange *self) { return TValueListMethods::_len(self); }
PyObject *ValueList_concat(TPyOrange *self, PyObject *obj) { return TValueListMethods::_concat(self, obj); }
PyObject *ValueList_repeat(TPyOrange *self, int times) { return TValueListMethods::_repeat(self, times); }
PyObject *ValueList_str(TPyOrange *self) { return TValueListMethods::_str(self); }
PyObject *ValueList_repr(TPyOrange *self) { return TValueListMethods::_str(self); }
int       ValueList_contains(TPyOrange *self, PyObject *obj) { return TValueListMethods::_contains(self, obj); }
PyObject *ValueList_append(TPyOrange *self, PyObject *item) PYARGS(METH_O, "(Value) -> None") { return TValueListMethods::_append(self, item); }
PyObject *ValueList_extend(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(sequence) -> None") { return TValueListMethods::_extend(self, obj); }
PyObject *ValueList_count(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(Value) -> int") { return TValueListMethods::_count(self, obj); }
PyObject *ValueList_filter(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "([filter-function]) -> ValueList") { return TValueListMethods::_filter(self, args); }
PyObject *ValueList_index(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(Value) -> int") { return TValueListMethods::_index(self, obj); }
PyObject *ValueList_insert(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(index, item) -> None") { return TValueListMethods::_insert(self, args); }
PyObject *ValueList_native(TPyOrange *self) PYARGS(METH_NOARGS, "() -> list") { return TValueListMethods::_native(self); }
PyObject *ValueList_pop(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "() -> Value") { return TValueListMethods::_pop(self, args); }
PyObject *ValueList_remove(TPyOrange *self, PyObject *obj) PYARGS(METH_O, "(Value) -> None") { return TValueListMethods::_remove(self, obj); }
PyObject *ValueList_reverse(TPyOrange *self) PYARGS(METH_NOARGS, "() -> None") { return TValueListMethods::_reverse(self); }
PyObject *ValueList_sort(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "([cmp-func]) -> None") { return TValueListMethods::_sort(self, args); }
PyObject *ValueList__reduce__(TPyOrange *self, PyObject *) { return TValueListMethods::_reduce(self); }



PyObject *VarTypes()
{ PyObject *vartypes=PyModule_New("VarTypes");
  PyModule_AddIntConstant(vartypes, "None", (int)TValue::NONE);
  PyModule_AddIntConstant(vartypes, "Discrete", (int)TValue::INTVAR);
  PyModule_AddIntConstant(vartypes, "Continuous", (int)TValue::FLOATVAR);
  PyModule_AddIntConstant(vartypes, "Other", (int)TValue::FLOATVAR+1); // for compatibility; don't use!
  PyModule_AddIntConstant(vartypes, "String", (int)STRINGVAR);
  return vartypes;
}

PYCONSTANTFUNC(VarTypes, VarTypes)


PyObject *ValueTypes()
{ PyObject *valuetypes=PyModule_New("ValueTypes");
  PyModule_AddIntConstant(valuetypes, "Regular", valueRegular);
  PyModule_AddIntConstant(valuetypes, "DC", valueDC);
  PyModule_AddIntConstant(valuetypes, "DK", valueDK);
  return valuetypes;
}

PYCONSTANTFUNC(ValueTypes, ValueTypes)


#include "cls_value.px"