FieldDefinition bindings

Author: LukasMolzberger

include/fields/abstract_function_definition.h

@@ -9,7 +9,7 @@
 class AbstractFunctionDefinition : public FieldDefinition {
 public:
     // Constructors
-    AbstractFunctionDefinition(Type* objectType, const std::string& name, int* numArgs, double tolerance);
+    AbstractFunctionDefinition(Type* objectType, const std::string& name, int numArgs, double tolerance);
 
     // Destructor
     virtual ~AbstractFunctionDefinition() = default;

include/fields/field_definition.h

@@ -35,10 +35,11 @@ class FieldDefinition {
 
 public:
 
-    FieldDefinition(Type* objectType, const std::string& name, int* numArgs, double tolerance);
+    FieldDefinition(Type* objectType, const std::string& name, int numArgs, double tolerance);
+    virtual ~FieldDefinition() = default;
 
     void setFieldId(int fieldId);
-    virtual void transmit(Field* targetField, FieldLinkDefinition* fieldLink, double update);
+    virtual void transmit(Field* targetField, FieldLinkDefinition* fieldLink, double update) = 0;
     void receiveUpdate(Field* field, double update);
 
     FieldDefinition* getParent() const;
@@ -54,6 +55,7 @@ class FieldDefinition {
     void addOutput(FieldLinkDefinition* fl);
     std::vector<FieldLinkDefinition*> getOutputs();
 
+    FieldDefinition& in(Relation* relation, FieldDefinition* input, int arg);
     FieldDefinition& out(Relation* relation, FieldDefinition* output, int arg);
 
     FieldDefinition& setName(const std::string& name);

include/fields/input_field.h

@@ -8,7 +8,6 @@
 #include "fields/obj.h"
 
 class InputField : public AbstractFunctionDefinition {
-    static int zero;
 
 public:
 

include/fields/subtraction.h

@@ -0,0 +1,19 @@
+#ifndef SUBTRACTION_H
+#define SUBTRACTION_H
+
+#include "fields/abstract_function_definition.h"
+#include "fields/type.h"
+#include "fields/obj.h"
+
+
+class Subtraction : public AbstractFunctionDefinition {
+public:
+
+    // Constructor
+    Subtraction(Type* ref, const std::string& name);
+
+    // Overridden method from AbstractFunctionDefinition
+    double computeUpdate(Obj* obj, FieldLinkDefinition* fl, double u) override;
+};
+
+#endif // SUBTRACTION_H

src/fields/abstract_function_definition.cpp

@@ -2,7 +2,7 @@
 
 
 // Constructor with 4 arguments
-AbstractFunctionDefinition::AbstractFunctionDefinition(Type* objectType, const std::string& name, int* numArgs, double tolerance)
+AbstractFunctionDefinition::AbstractFunctionDefinition(Type* objectType, const std::string& name, int numArgs, double tolerance)
     : FieldDefinition(objectType, name, numArgs, tolerance) {}
 
 // Transmit method

src/fields/field_definition.cpp

@@ -8,13 +8,13 @@
 #include "fields/obj.h"
 
 
-FieldDefinition::FieldDefinition(Type* objectType, const std::string& name, int* numArgs, double tolerance)
+FieldDefinition::FieldDefinition(Type* objectType, const std::string& name, int numArgs, double tolerance)
     : objectType(objectType), name(name), isNextRound(false) {
     this->tolerance = tolerance;
     objectType->setFieldDefinition(this);
 
-    if (numArgs != nullptr) {
-        inputs.reserve(*numArgs);
+    if (numArgs > 0) {
+        inputs.reserve(numArgs);
     }
 }
 
@@ -81,6 +81,12 @@ std::vector<FieldLinkDefinition*> FieldDefinition::getOutputs() {
     return outputs;
 }
 
+FieldDefinition& FieldDefinition::in(Relation* relation, FieldDefinition* input, int arg) {
+    FieldLinkDefinition::link(input, this, relation, arg);
+//    assert(relation || objectType->isInstanceOf(output->getObjectType()) || output->getObjectType()->isInstanceOf(objectType));
+    return *this;
+}
+
 FieldDefinition& FieldDefinition::out(Relation* relation, FieldDefinition* output, int arg) {
     FieldLinkDefinition::link(this, output, relation, arg);
 //    assert(relation || objectType->isInstanceOf(output->getObjectType()) || output->getObjectType()->isInstanceOf(objectType));

src/fields/input_field.cpp

@@ -3,7 +3,7 @@
 
 // Constructor
 InputField::InputField(Type* ref, const std::string& name)
-    : AbstractFunctionDefinition(ref, name, &zero, 0.0) {}
+    : AbstractFunctionDefinition(ref, name, 0, 0.0) {}
 
 // Overridden computeUpdate method
 double InputField::computeUpdate(Obj* obj, FieldLinkDefinition* fl, double u) {

src/fields/subtraction.cpp

@@ -0,0 +1,11 @@
+#include "fields/subtraction.h"
+
+
+// Constructor
+Subtraction::Subtraction(Type* ref, const std::string& name)
+    : AbstractFunctionDefinition(ref, name, 0, 0.0) {}
+
+// Overridden computeUpdate method
+double Subtraction::computeUpdate(Obj* obj, FieldLinkDefinition* fl, double u) {
+    return (fl->getArgument() == 0) ? u : -u;
+}

src/fields/type_registry_python.cpp

@@ -1,9 +1,11 @@
 #include <pybind11/pybind11.h>
 
+#include "fields/field_definition.h"
 #include "fields/field_update.h"
 #include "fields/type.h"
 #include "fields/type_registry.h"
 #include "fields/input_field.h"
+#include "fields/subtraction.h"
 
 
 // ----------------
@@ -14,23 +16,51 @@ namespace py = pybind11;
 
 PYBIND11_MODULE(aika, m)
 {
-  py::class_<FieldUpdate>(m, "FieldUpdate")
-  .def(py::init<ProcessingPhase&, QueueInterceptor*>());
-
-  py::class_<Type>(m, "Type")
-  .def(py::init<TypeRegistry*, const std::string&>())
-  .def("__str__", [](const Type &t) {
-        return t.toString();
-  })
-  .def("inputField", [](const Type &ref, const std::string &name) {
-      return new InputField(
-                const_cast<Type*>(&ref),
-                name
-        );
-  });
-
-  py::class_<TypeRegistry>(m, "TypeRegistry")
-    .def(py::init<>())
-    .def("getType", &TypeRegistry::getType)
-    .def("registerType", &TypeRegistry::registerType);
+      // Bind Relation
+      py::class_<Relation>(m, "Relation");
+
+      py::class_<FieldUpdate>(m, "FieldUpdate")
+            .def(py::init<ProcessingPhase&, QueueInterceptor*>());
+
+      // Bind FieldDefinition first
+      py::class_<FieldDefinition>(m, "FieldDefinition")
+            .def("in", &FieldDefinition::in, py::return_value_policy::reference_internal, 
+                  py::arg("relation"), py::arg("input"), py::arg("arg"))
+            .def("out", &FieldDefinition::out, py::return_value_policy::reference_internal, 
+                  py::arg("relation"), py::arg("output"), py::arg("arg"));
+
+      // Bind AbstractFunctionDefinition (inherits from FieldDefinition)
+      py::class_<AbstractFunctionDefinition, FieldDefinition>(m, "AbstractFunctionDefinition");
+
+      // Bind Subtraction (inherits from AbstractFunctionDefinition)
+      py::class_<Subtraction, AbstractFunctionDefinition>(m, "Subtraction");
+
+      py::class_<InputField>(m, "InputField")
+            .def(py::init<Type*, const std::string &>())
+            .def("__str__", [](const InputField &f) {
+                  return f.toString();
+            });
+
+      py::class_<Type>(m, "Type")
+            .def(py::init<TypeRegistry*, const std::string&>())
+            .def("__str__", [](const Type &t) {
+                  return t.toString();
+            })
+            .def("inputField", [](const Type &ref, const std::string &name) {
+                  return new InputField(
+                        const_cast<Type*>(&ref),
+                        name
+                  );
+            }, py::return_value_policy::take_ownership)
+            .def("sub", [](const Type &ref, const std::string &name) {
+                  return new Subtraction(
+                        const_cast<Type*>(&ref),
+                        name
+                  );
+            }, py::return_value_policy::take_ownership);
+
+      py::class_<TypeRegistry>(m, "TypeRegistry")
+            .def(py::init<>())
+            .def("getType", &TypeRegistry::getType)
+            .def("registerType", &TypeRegistry::registerType);
 }

tests/test_basic.py

@@ -7,5 +7,5 @@
 
 tr = aika.TypeRegistry()
 
-t =aika.Type(tr)
+t = aika.Type(tr)