feat: join

src/safeds/data/tabular/containers/_table.py

@@ -1708,6 +1708,22 @@ def inverse_transform_table(self, fitted_transformer: InvertibleTableTransformer
         """
         return fitted_transformer.inverse_transform(self)
 
+    def join(
+        self,
+        right_table: Table,
+        left_names: str | list[str],
+        right_names: str | list[str],
+        *,
+        mode: Literal["inner", "left", "outer"] = "inner",
+    ) -> Table:
+        joined_dataframe = self._data_frame.join(
+            right_table._data_frame,
+            left_on=left_names,
+            right_on=right_names,
+            how=mode,
+        )
+        return self._from_polars_data_frame(joined_dataframe)
+
     def transform_table(self, fitted_transformer: TableTransformer) -> Table:
         """
         Return a new table transformed by a **fitted** transformer.

src/safeds/ml/classical/classification/_logistic_classifier.py

@@ -17,8 +17,9 @@ class LogisticClassifier(Classifier):
     # Dunder methods
     # ------------------------------------------------------------------------------------------------------------------
 
-    def __init__(self) -> None:
+    def __init__(self, c: float = 1.0) -> None:
         super().__init__()
+        self.c = c
 
     def __hash__(self) -> int:
         return _structural_hash(
@@ -30,12 +31,13 @@ def __hash__(self) -> int:
     # ------------------------------------------------------------------------------------------------------------------
 
     def _clone(self) -> LogisticClassifier:
-        return LogisticClassifier()
+        return LogisticClassifier(c=self.c)
 
     def _get_sklearn_model(self) -> ClassifierMixin:
         from sklearn.linear_model import LogisticRegression as SklearnLogisticRegression
 
         return SklearnLogisticRegression(
             random_state=_get_random_seed(),
             n_jobs=-1,
+            C=self.c,
         )

tests/safeds/data/tabular/containers/_table/test_join.py

@@ -0,0 +1,60 @@
+from typing import Literal
+
+import pytest
+from safeds.data.tabular.containers import Table
+
+
+@pytest.mark.parametrize(
+    ("table_left", "table_right", "left_names", "right_names", "mode", "table_expected"),
+    [
+        (
+            Table({"a": [1, 2], "b": [3, 4]}),
+            Table({"d": [1, 5], "e": [5, 6]}),
+            ["a"],
+            ["d"],
+            "outer",
+            Table({"a": [1, None, 2], "b": [3, None, 4], "d": [1, 5, None], "e": [5, 6, None]}),
+        ),
+        (
+            Table({"a": [1, 2], "b": [3, 4]}),
+            Table({"d": [1, 5], "e": [5, 6]}),
+            ["a"],
+            ["d"],
+            "left",
+            Table({"a": [1, 2], "b": [3, 4], "e": [5, None]}),
+        ),
+        (
+            Table({"a": [1, 2], "b": [3, 4]}),
+            Table({"d": [1, 5], "e": [5, 6]}),
+            ["a"],
+            ["d"],
+            "inner",
+            Table({"a": [1], "b": [3], "e": [5]}),
+        ),
+        (
+            Table({"a": [1, 2], "b": [3, 4], "c": [5, 6]}),
+            Table({"d": [1, 5], "e": [5, 6], "g": [7, 9]}),
+            ["a", "c"],
+            ["d", "e"],
+            "inner",
+            Table({"a": [1], "b": [3], "c": [5], "g": [7]}),
+        ),
+        (
+            Table({"a": [1, 2], "b": [3, 4]}),
+            Table({"d": [1, 5], "e": [5, 6]}),
+            ["b"],
+            ["e"],
+            "inner",
+            Table({"a": [], "b": [], "d": []}),
+        ),
+    ],
+)
+def test_join(
+    table_left: Table,
+    table_right: Table,
+    left_names: list[str],
+    right_names: list[str],
+    mode: Literal["inner", "left", "outer"],
+    table_expected: Table,
+) -> None:
+    assert table_left.join(table_right, left_names, right_names, mode=mode) == table_expected

tests/safeds/ml/classical/classification/test_logistic_classifier.py

@@ -0,0 +1,27 @@
+import pytest
+from safeds.data.labeled.containers import TabularDataset
+from safeds.data.tabular.containers import Table
+from safeds.ml.classical.classification import LogisticClassifier
+
+
+@pytest.fixture()
+def training_set() -> TabularDataset:
+    table = Table({"col1": [1, 2, 3, 4], "col2": [1, 2, 3, 4]})
+    return table.to_tabular_dataset(target_name="col1")
+
+
+class TestC:
+    def test_should_be_passed_to_fitted_model(self, training_set: TabularDataset) -> None:
+        fitted_model = LogisticClassifier(c=2).fit(training_set)
+        assert fitted_model.c == 2
+
+    def test_should_be_passed_to_sklearn(self, training_set: TabularDataset) -> None:
+        fitted_model = LogisticClassifier(c=2).fit(training_set)
+        assert fitted_model._wrapped_model is not None
+        assert fitted_model._wrapped_model.C == 2
+
+    def test_clone(self, training_set: TabularDataset) -> None:
+        fitted_model = LogisticClassifier(c=2).fit(training_set)
+        cloned_classifier = fitted_model._clone()
+        assert isinstance(cloned_classifier, LogisticClassifier)
+        assert cloned_classifier.c == fitted_model.c