public void SimpleFloatMath()
{
runBasicTest("a = 10.0 * (2.0 + 4.0) / 3.0\n", new VariableMultimap(new TupleList <string, object>
{
{ "a", PyFloat.Create(20.0) }
}), 1);
}
public static object ToCLI(this PyObject o)
{
if (PySequence.IsSequenceType(o))
{
var list = new List <object>();
foreach (PyObject subo in o)
{
list.Add(subo.ToCLI());
}
return(list);
}
if (PyString.IsStringType(o))
{
return(o.As <string>());
}
if (PyInt.IsIntType(o))
{
return(o.As <long>());
}
if (PyLong.IsLongType(o))
{
return(o.As <long>());
}
if (PyFloat.IsFloatType(o))
{
return(o.As <double>());
}
return(o);
}
public void ComprehensiveArithmeticOperators()
{
runBasicTest(
"x = 10\n" +
"a = x + 2\n" +
"b = x - 2\n" +
"c = x * 2\n" +
"d = x / 2\n" +
"e = x % 9\n" +
"f = x // 3\n" +
"g = x ** 2\n" +
"h = x & 2\n" +
"i = x | 14\n" +
"j = x ^ 2\n" +
"k = x >> 2\n" +
"l = x << 2\n"
, new VariableMultimap(new TupleList <string, object>
{
{ "a", PyInteger.Create(12) },
{ "b", PyInteger.Create(8) },
{ "c", PyInteger.Create(20) },
{ "d", PyFloat.Create(5.0) },
{ "e", PyInteger.Create(1) },
{ "f", PyInteger.Create(3) },
{ "g", PyInteger.Create(100) },
{ "h", PyInteger.Create(2) },
{ "i", PyInteger.Create(14) },
{ "j", PyInteger.Create(8) },
{ "k", PyInteger.Create(2) },
{ "l", PyInteger.Create(40) }
}), 1);
}
public void RepeatedArithmeticOperators()
{
// Making sure that we're properly parsing and generating all of these when there's multiples of the operator.
runBasicTest(
"x = 100\n" +
"a = x + 2 + 3\n" +
"b = x - 2 - 3\n" +
"c = x * 2 * 3\n" +
"d = x / 4 / 2\n" +
"e = x % 9 % 3\n" +
"f = x // 2 // 3\n" +
"g = x ** 2 ** 3\n" +
"h = x & 3 & 2\n" +
"i = x | 13 | 1 \n" +
"j = x ^ 2 ^ 1\n" +
"k = x >> 2 >> 3\n" +
"l = x << 2 << 3\n"
, new VariableMultimap(new TupleList <string, object>
{
{ "a", PyInteger.Create(100 + 2 + 3) },
{ "b", PyInteger.Create(100 - 2 - 3) },
{ "c", PyInteger.Create(100 * 2 * 3) },
{ "d", PyFloat.Create(100.0 / 4.0 / 2.0) },
{ "e", PyInteger.Create(100 % 9 % 3) },
{ "f", PyInteger.Create(100 / 2 / 3) },
{ "g", PyInteger.Create((BigInteger)Math.Pow(100.0, 8.0)) }, // 2 ** 3 gets evaluated first and becomes 8. This is what CPython does too!
{ "h", PyInteger.Create(100 & 3 & 2) },
{ "i", PyInteger.Create(100 | 13 | 1) },
{ "j", PyInteger.Create(100 ^ 2 ^ 1) },
{ "k", PyInteger.Create(100 >> 2 >> 3) },
{ "l", PyInteger.Create(100 << 2 << 3) }
}), 1);
}
public void IntPtrCtor()
{
var i = new PyFloat(1);
var ii = new PyFloat(i.Handle);
Assert.AreEqual(i.Handle, ii.Handle);
}
public async Task SimpleIntMath()
{
await runBasicTest("a = 10 * (2 + 4) / 3\n", new VariableMultimap(new TupleList <string, object>
{
{ "a", PyFloat.Create(20.0) }
}), 1);
}
public void IsFloatTrue()
{
const double a = 4.5;
var i = new PyFloat(a);
Assert.True(PyFloat.IsFloatType(i));
}
public void StringDoubleCtor()
{
const string a = "4.5";
var i = new PyFloat(a);
Assert.True(PyFloat.IsFloatType(i));
// Assert.Assert.AreEqual(i, a.ToInt32());
}
public void FloatCtor()
{
const float a = 4.5F;
var i = new PyFloat(a);
Assert.True(PyFloat.IsFloatType(i));
// Assert.Assert.AreEqual(i, a.ToInt32());
}
public void DoubleCtor()
{
const double a = 4.5;
var i = new PyFloat(a);
Assert.True(PyFloat.IsFloatType(i));
// Assert.Assert.AreEqual(i, a.ToInt32());
}
public void PyObjectCtorGood()
{
var i = new PyFloat(5);
var a = new PyFloat(i);
Assert.True(PyFloat.IsFloatType(a));
// Assert.Assert.AreEqual(i, a.ToInt32());
}
public void AsFloatGood()
{
const double a = 4.5;
var i = new PyFloat(a);
PyFloat s = PyFloat.AsFloat(i);
Assert.True(PyFloat.IsFloatType(s));
// Assert.Assert.AreEqual(i, a.ToInt32());
}
public void AssignmentOperators()
{
// https://www.w3schools.com/python/python_operators.asp
// += x += 3 x = x + 3
// -= x -= 3 x = x - 3
// *= x *= 3 x = x * 3
// /= x /= 3 x = x / 3
// %= x %= 3 x = x % 3
// //= x //= 3 x = x // 3
// **= x **= 3 x = x ** 3
// &= x &= 3 x = x & 3
// |= x |= 3 x = x | 3
// ^= x ^= 3 x = x ^ 3
// >>= x >>= 3 x = x >> 3
// <<= x <<= 3 x = x << 3
runBasicTest(
"a = 10\n" +
"b = 10\n" +
"c = 10\n" +
"d = 10\n" +
"e = 10\n" +
"f = 10\n" +
"g = 10\n" +
"h = 10\n" +
"i = 10\n" +
"j = 10\n" +
"k = 10\n" +
"l = 10\n" +
"a += 2\n" +
"b -= 2\n" +
"c *= 2\n" +
"d /= 2\n" +
"e %= 9\n" +
"f //= 3\n" +
"g **= 2\n" +
"h &= 2\n" +
"i |= 14\n" +
"j ^= 2\n" +
"k >>= 2\n" +
"l <<= 2\n"
, new VariableMultimap(new TupleList <string, object>
{
{ "a", PyInteger.Create(12) },
{ "b", PyInteger.Create(8) },
{ "c", PyInteger.Create(20) },
{ "d", PyFloat.Create(5.0) },
{ "e", PyInteger.Create(1) },
{ "f", PyInteger.Create(3) },
{ "g", PyInteger.Create(100) },
{ "h", PyInteger.Create(2) },
{ "i", PyInteger.Create(14) },
{ "j", PyInteger.Create(8) },
{ "k", PyInteger.Create(2) },
{ "l", PyInteger.Create(40) }
}), 1);
}
public void PyObjectCtorBad()
{
var i = new PyString("Foo");
PyFloat a = null;
var ex = Assert.Throws <ArgumentException>(() => a = new PyFloat(i));
StringAssert.StartsWith("object is not a float", ex.Message);
Assert.IsNull(a);
}
public void AsFloatBad()
{
var s = new PyString("Foo");
PyFloat a = null;
var ex = Assert.Throws <PythonException>(() => a = PyFloat.AsFloat(s));
StringAssert.StartsWith("could not convert string to float", ex.Message);
Assert.IsNull(a);
}
public void StringBadCtor()
{
const string i = "Foo";
PyFloat a = null;
var ex = Assert.Throws <PythonException>(() => a = new PyFloat(i));
StringAssert.StartsWith("could not convert string to float", ex.Message);
Assert.IsNull(a);
}
public static object CreateNumber(IParseTree context)
{
string rawText = context.GetText();
if (DecimalPointNumberRegex.Match(rawText).Success)
{
return(PyFloat.Create(Decimal.Parse(rawText)));
}
return(PyInteger.Create(BigInteger.Parse(context.GetText())));
}
public void BasicWait()
{
runBasicTest(
"a = 10 * (2 + 4) / 3\n" +
"wait\n" +
"b = a + 3\n", new VariableMultimap(new TupleList <string, object>
{
{ "a", PyFloat.Create(20.0) },
{ "b", PyFloat.Create(23.0) }
}), 2);
}
public void TestConvertSingleToManaged(
[Values(float.PositiveInfinity, float.NegativeInfinity, float.MinValue, float.MaxValue, float.NaN,
float.Epsilon)] float testValue)
{
var pyFloat = new PyFloat(testValue);
object convertedValue;
var converted = Converter.ToManaged(pyFloat.Handle, typeof(float), out convertedValue, false);
Assert.IsTrue(converted);
Assert.IsTrue(((float)convertedValue).Equals(testValue));
}
public void TestConvertDoubleToManaged(
[Values(double.PositiveInfinity, double.NegativeInfinity, double.MinValue, double.MaxValue, double.NaN,
double.Epsilon)] double testValue)
{
var pyFloat = new PyFloat(testValue);
object convertedValue;
var converted = Converter.ToManaged(pyFloat.Handle, typeof(double), out convertedValue, false);
Assert.IsTrue(converted);
Assert.IsTrue(((double)convertedValue).Equals(testValue));
}
public CrossValidationSet(string estimator, string estimatorname, string datasetname, PyObject dataset, int rowstart, int rowfinish, PyObject attributes, CVObject cvObject, PyObject PyModule)
{
Estimator = new PyString(estimator);
EstimatorName = estimatorname;
DatasetName = datasetname;
Dataset = dataset;
Rowstart = new PyInt(rowstart);
Rowfinish = new PyInt(rowfinish);
Attributes = attributes;
CV = new PyString(cvObject.Type);
CVparams = new PyDict();
if (cvObject.N_groups != 0)
{
CVparams["n_groups"] = new PyInt(cvObject.N_groups);
}
if (cvObject.N_splits != 0)
{
CVparams["n_splits"] = new PyInt(cvObject.N_splits);
}
if (cvObject.P != 0)
{
CVparams["p"] = new PyInt(cvObject.P);
}
if (cvObject.Shuffle)
{
CVparams["shuffle"] = true.ToPython();
}
if (cvObject.Train_size != null)
{
if (cvObject.Train_size.GetType().Name == "Int32")
{
CVparams["train_size"] = new PyInt((int)cvObject.Train_size);
}
if (cvObject.Train_size.GetType().Name == "Double")
{
CVparams["train_size"] = new PyFloat((double)cvObject.Train_size);
}
}
if (cvObject.Test_size != null)
{
if (cvObject.Test_size.GetType().Name == "Int32")
{
CVparams["test_size"] = new PyInt((int)cvObject.Test_size);
}
if (cvObject.Test_size.GetType().Name == "Double")
{
CVparams["test_size"] = new PyFloat((double)cvObject.Test_size);
}
}
_pymodule = PyModule;
}
public static double GetDouble(dynamic dynDoublePyObj, ref double?doubleMember)
{
if (doubleMember != null)
{
return((double)doubleMember);
}
using (Py.GIL())
{
var dynDoublePyFloat = PyFloat.AsFloat(dynDoublePyObj);
doubleMember = dynDoublePyFloat.As <double>();
return((double)doubleMember);
}
}
public void CanDecode()
{
var pyint = new PyInt(10).GetPythonType();
var pyfloat = new PyFloat(10).GetPythonType();
var pystr = new PyString("world").GetPythonType();
var decoder1 = new DecoderReturningPredefinedValue <long>(pyint, decodeResult: 42);
var decoder2 = new DecoderReturningPredefinedValue <string>(pyfloat, decodeResult: "atad:");
var group = new DecoderGroup {
decoder1,
decoder2,
};
Assert.IsTrue(group.CanDecode(pyint, typeof(long)));
Assert.IsFalse(group.CanDecode(pyint, typeof(int)));
Assert.IsTrue(group.CanDecode(pyfloat, typeof(string)));
Assert.IsFalse(group.CanDecode(pystr, typeof(string)));
}
public void Decodes()
{
var pyint = new PyInt(10).GetPythonType();
var pyfloat = new PyFloat(10).GetPythonType();
var decoder1 = new DecoderReturningPredefinedValue <long>(pyint, decodeResult: 42);
var decoder2 = new DecoderReturningPredefinedValue <string>(pyfloat, decodeResult: "atad:");
var group = new DecoderGroup {
decoder1,
decoder2,
};
Assert.IsTrue(group.TryDecode(new PyInt(10), out long longResult));
Assert.AreEqual(42, longResult);
Assert.IsTrue(group.TryDecode(new PyFloat(10), out string strResult));
Assert.AreSame("atad:", strResult);
Assert.IsFalse(group.TryDecode(new PyInt(10), out int _));
}
// TODO: Make every part of this much easier. Creating the objects properly will need to be simplified. One-step
// construction with passed-in values will greatly help. This could be done with a factory, but we should investigate
// if we can just use the basic type constructors in some way first.
public async Task <PyTuple> get_player_pos_wrapper(IInterpreter interpreter, FrameContext context)
{
PyFloat f1 = (PyFloat)await PyFloatClass.Instance.Call(interpreter, context, new object[0]);
f1.number = Decimal.Parse(playerXLabel.Text);
PyFloat f2 = (PyFloat)await PyFloatClass.Instance.Call(interpreter, context, new object[0]);
f2.number = Decimal.Parse(playerYLabel.Text);
var tuples = new PyObject[2]
{
f1,
f2
};
var new_pytup = (PyTuple)await PyTupleClass.Instance.Call(interpreter, context, new object[0]);
new_pytup.Values = tuples;
return(new_pytup);
}
public object ReadValue(uint?me_value)
{
PyTypeObject typeObject = new PyObject(me_value.Value, MemoryReader).LoadType(PyMemoryReader);
object value = null;
switch (typeObject.tp_name_Val)
{
case "str":
value = new PyStr(me_value.Value, MemoryReader);
break;
case "float":
value = new PyFloat(me_value.Value, MemoryReader);
break;
case "int":
value = new PyInt(me_value.Value, MemoryReader);
break;
case "bool":
value = new PyBool(me_value.Value, MemoryReader);
break;
case "unicode":
value = new PyUnicode(me_value.Value, MemoryReader);
break;
case "list":
value = new PyList(me_value.Value, MemoryReader);
break;
default:
break;
}
if (value != null)
{
return(value);
}
return(me_value?.ToString("x"));
}
public object ReadValue(PyObject obj)
{
PyTypeObject typeObject = obj.LoadType(PyMemoryReader);
object value = null;
switch (typeObject.tp_name_Val)
{
case "str":
value = new PyStr(obj.BaseAddress, MemoryReader);
break;
case "float":
value = new PyFloat(obj.BaseAddress, MemoryReader);
break;
case "int":
value = new PyInt(obj.BaseAddress, MemoryReader);
break;
case "bool":
value = new PyBool(obj.BaseAddress, MemoryReader);
break;
case "unicode":
value = new PyUnicode(obj.BaseAddress, MemoryReader);
break;
case "list":
value = new PyList(obj.BaseAddress, MemoryReader);
break;
default:
break;
}
if (value != null)
{
return(value);
}
return(obj.BaseAddress.ToString("x"));
}
public async Task NumericStringConversions()
{
await runBasicTest(
"a_string = '1'\n" +
"as_int = int(a_string)\n" +
"as_float = float(a_string)\n" +
"as_bool = bool(a_string)\n" +
"int_str = str(1)\n" +
"float_str = str(1.0)\n" +
"bool_str = str(True)\n",
new VariableMultimap(new TupleList <string, object>
{
{ "as_int", PyInteger.Create(1) },
{ "as_float", PyFloat.Create(1.0) },
{ "as_bool", PyBool.True },
{ "int_str", PyString.Create("1") },
{ "float_str", PyString.Create("1.0") },
{ "bool_str", PyString.Create("True") },
}), 1);
}
public void GetDecodersByTypes()
{
var pyint = new PyInt(10).GetPythonType();
var pyfloat = new PyFloat(10).GetPythonType();
var pystr = new PyString("world").GetPythonType();
var decoder1 = new DecoderReturningPredefinedValue <long>(pyint, decodeResult: 42);
var decoder2 = new DecoderReturningPredefinedValue <string>(pyfloat, decodeResult: "atad:");
var group = new DecoderGroup {
decoder1,
decoder2,
};
var decoder = group.GetDecoder(pyfloat, typeof(string));
Assert.AreSame(decoder2, decoder);
decoder = group.GetDecoder(pystr, typeof(string));
Assert.IsNull(decoder);
decoder = group.GetDecoder(pyint, typeof(long));
Assert.AreSame(decoder1, decoder);
}
public void IsFloatFalse()
{
var i = new PyString("Foo");
Assert.False(PyFloat.IsFloatType(i));
}
