Implemented div operator

Author: LukasMolzberger

CMakeLists.txt

@@ -19,6 +19,7 @@ set(SOURCES
         src/fields/addition.cpp
         src/fields/subtraction.cpp
         src/fields/multiplication.cpp
+        src/fields/division.cpp
         src/fields/field_link_definition.cpp
         src/fields/obj.cpp
         src/fields/type.cpp

include/fields/division.h

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

install_manifest.txt

@@ -25,4 +25,5 @@
 /Users/lukasmolzberger/CLionProjects/aika-cpp/.venv/lib/python3.12/site-packages/aika/include/fields/flattened_type.h
 /Users/lukasmolzberger/CLionProjects/aika-cpp/.venv/lib/python3.12/site-packages/aika/include/fields/rel_obj_iterator.h
 /Users/lukasmolzberger/CLionProjects/aika-cpp/.venv/lib/python3.12/site-packages/aika/include/fields/queue_key.h
-/Users/lukasmolzberger/CLionProjects/aika-cpp/.venv/lib/python3.12/site-packages/aika/include/fields/queue.h
+/Users/lukasmolzberger/CLionProjects/aika-cpp/.venv/lib/python3.12/site-packages/aika/include/fields/queue.h
+/Users/lukasmolzberger/CLionProjects/aika-cpp/.venv/lib/python3.12/site-packages/aika/include/fields/division.h

python-tests/division-test.py

@@ -0,0 +1,81 @@
+import unittest
+import sys
+import os
+from parameterized import parameterized
+
+# Add the project root to Python's module search path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+import aika
+
+class DivisionTestCase(unittest.TestCase):
+
+    @parameterized.expand([
+        (0, "linking_pos_0"),
+        (1, "linking_pos_1"),
+        (2, "linking_pos_2")
+    ])
+    def testDivision(self, linking_pos, test_name):
+        print("Module 'aika' was loaded from:", aika.__file__)
+
+        TEST_RELATION_FROM = aika.RelationOne(1, "TEST_FROM")
+        TEST_RELATION_TO = aika.RelationOne(2, "TEST_TO")
+        TEST_RELATION_TO.setReversed(TEST_RELATION_FROM)
+        TEST_RELATION_FROM.setReversed(TEST_RELATION_TO)
+
+        assert isinstance(TEST_RELATION_FROM, aika.Relation)
+        assert isinstance(TEST_RELATION_TO, aika.Relation)
+
+        registry = aika.TypeRegistry()
+
+        typeA = aika.TestType(registry, "A")
+        typeB = aika.TestType(registry, "B")
+
+        a = typeA.inputField("a")
+        b = typeA.inputField("b")
+
+        c = typeB.div("c")
+
+        print("Type of c:", type(c))
+        print("Type of TEST_RELATION_FROM:", type(TEST_RELATION_FROM))
+        print("Type of a:", type(a))
+
+        assert isinstance(a, aika.FieldDefinition)
+        assert isinstance(c, aika.FieldDefinition)
+
+        c.input(TEST_RELATION_FROM, a, 0)
+        c.input(TEST_RELATION_FROM, b, 1)
+
+        registry.flattenTypeHierarchy()
+
+        oa = typeA.instantiate()
+        ob = typeB.instantiate()
+
+        print("linking_pos:", linking_pos)
+
+        if linking_pos == 0:
+            aika.TestObj.linkObjects(oa, ob)
+            ob.initFields()
+
+        oa.setFieldValue(a, 50.0)
+        print("oa.getFieldValue(a):", oa.getFieldValue(a))
+
+        if linking_pos == 1:
+            aika.TestObj.linkObjects(oa, ob)
+            ob.initFields()
+
+        oa.setFieldValue(b, 2.0)
+        print("oa.getFieldValue(b):", oa.getFieldValue(b))
+
+        if linking_pos == 2:
+            aika.TestObj.linkObjects(oa, ob)
+            ob.initFields()
+
+        print("ob.getFieldValue(c):", ob.getFieldValue(c))
+
+        print("ob.getFieldAsString(c):", ob.getFieldAsString(c))
+
+        self.assertEqual(25.0, ob.getFieldValue(c))
+
+if __name__ == '__main__':
+    unittest.main() 

src/fields/division.cpp

@@ -0,0 +1,43 @@
+#include "fields/division.h"
+
+// Constructor
+Division::Division(Type* ref, const std::string& name)
+    : AbstractFunctionDefinition(ref, name, 2, 0.0) {}
+
+void Division::initializeField(Field* field) {
+    Obj* toObj = field->getObject();
+    FieldDefinition* fieldDef = field->getFieldDefinition();
+    std::vector<FieldLinkDefinition*> inputs = fieldDef->getInputs();
+    double dividend = inputs[0]->getInputValue(toObj);
+    double divisor = inputs[1]->getInputValue(toObj);
+
+    if (divisor == 0.0) {
+        // Handle division by zero if necessary
+        return;
+    }
+
+    field->setValue(dividend / divisor);
+}
+
+// Overridden computeUpdate method
+// This method computes the update for the division operation
+// based on which argument is being updated.
+double Division::computeUpdate(Obj* obj, FieldLinkDefinition* fl, double u) {
+    if (fl->getArgument() == 0) {
+        double divisor = getInputs()[1]->getInputValue(obj);
+        if (divisor == 0.0) {
+            // Handle division by zero if necessary
+            return 0.0;
+        }
+        return u / divisor;
+    } else {
+        double dividend = getInputs()[0]->getInputValue(obj);
+        double divisor = getInputs()[1]->getUpdatedInputValue(obj);
+        if (divisor == 0.0) {
+            // Handle division by zero if necessary
+            return 0.0;
+        }
+        double oldValue = obj->getFieldValue(this);
+        return (dividend / divisor) - oldValue;
+    }
+} 

src/fields/python_bindings.cpp

@@ -13,6 +13,7 @@
 #include "fields/field.h"
 #include "fields/addition.h"
 #include "fields/multiplication.h"
+#include "fields/division.h"
 
 
 // ----------------
@@ -57,6 +58,9 @@ PYBIND11_MODULE(aika, m)
       // Bind Multiplication (inherits from AbstractFunctionDefinition)
       py::class_<Multiplication, AbstractFunctionDefinition>(m, "Multiplication");
 
+      // Bind Division (inherits from AbstractFunctionDefinition)
+      py::class_<Division, AbstractFunctionDefinition>(m, "Division");
+
       py::class_<InputField, FieldDefinition>(m, "InputField")
             .def(py::init<Type*, const std::string &>())
             .def("__str__", [](const InputField &f) {
@@ -91,6 +95,12 @@ PYBIND11_MODULE(aika, m)
                         const_cast<Type*>(&ref),
                         name
                   );
+            }, py::return_value_policy::reference_internal)
+            .def("div", [](const Type &ref, const std::string &name) {
+                  return new Division(
+                        const_cast<Type*>(&ref),
+                        name
+                  );
             }, py::return_value_policy::reference_internal);
 
       py::class_<Obj>(m, "Obj")