diff --git a/.idea/runConfigurations/All_Tests.xml b/.idea/runConfigurations/All_Tests.xml
index 6c15e35..fe7ea16 100644
--- a/.idea/runConfigurations/All_Tests.xml
+++ b/.idea/runConfigurations/All_Tests.xml
@@ -1,10 +1,11 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="All Tests" type="tests" factoryName="Unittests">
     <module name="pylinkage" />
+    <option name="ENV_FILES" value="" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
-    <option name="SDK_HOME" value="/usr/bin/python3.10" />
-    <option name="SDK_NAME" value="Python 3.10" />
+    <option name="SDK_HOME" value="$PROJECT_DIR$/.venv/bin/python" />
+    <option name="SDK_NAME" value="Python 3.12 (pylinkage)" />
     <option name="WORKING_DIRECTORY" value="" />
     <option name="IS_MODULE_SDK" value="false" />
     <option name="ADD_CONTENT_ROOTS" value="true" />
diff --git a/CHANGELOG.md b/CHANGELOG.md
index adf1607..713a458 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,9 @@ optimization, related to ([#5](https://github.com/HugoFara/pylinkage/issues/5)).
 - Some run configuration files added *for users of PyCharm*:
   - Run all tests with "All Tests".
   - Regenerate documentation with "Sphinx Documentation".
+- The ``Linear`` joint is here! His geometric model was of course implemented.
+- ``line_from_points`` and ``circle_line_intersection``.
+- New exception ``NotCompletelyDefinedError``, when a joint is reloading but its anchor coordinates are set to None.
 
 ### Changed
 
@@ -52,12 +55,16 @@ iteration.
   - From the user perspective, no change (execution *may* be a bit faster)
   - ``source/`` renamed to ``sphinx/`` because it was confusing and only for Sphinx configuration.
 - Transition from Numpydoc to reST for docstrings ([#12](https://github.com/HugoFara/pylinkage/issues/12)).
+- ``__secant_circles_intersections__`` renamed to
+``secant_circles_intersections`` in ``geometry.py``.
 
 ### Fixed
 
 - ``swarm_tiled_repr`` in ``visualizer.py`` was wrongly assigning dimensions.
 - Setting ``locus_highlight`` in ``plot_static_linkage`` would result in an error.
-- ``Pivot.reload`` was returning arbitrary point when we had an infinity of solutions. 
+- ``Pivot.reload`` was returning arbitrary point when we had an infinity of solutions.
+- The highlighted locus was sometimes buggy in ``plot_static_linkage`` in 
+``visualizer.py``.
 
 ### Deprecated
 
@@ -66,6 +73,9 @@ iteration.
 - The ``Pivot`` class is deprecated in favor of the ``Revolute`` class. 
 The name "Pivot joint" is not standard. 
 Related to [#13](https://github.com/HugoFara/pylinkage/issues/13).
+- The ``hyperstaticity`` method is renamed ``indeterminacy`` in ``Linkage`` 
+(linkage.py)
+
 
 ## [0.5.3] - 2023-06-23
 
@@ -103,8 +113,8 @@ It will no longer be tested, use it at your own risks!
 
 ### Added in 0.5.2
 
-- You can see the best score and the best dimensions updating in 
-  ``trials_and_errors_optimization``.
+ - You can see the best score and best dimensions updating in 
+   ``trials_and_errors_optimization``.
 
 ### Changed in 0.5.2
 
diff --git a/README.md b/README.md
index cd862a3..d34077a 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ import pylinkage as pl
 # Main motor
 crank = pl.Crank(0, 1, joint0=(0, 0), angle=.31, distance=1)
 # Close the loop
-pin = pl.Pivot(
+pin = pl.Revolute(
     3, 2, joint0=crank, joint1=(3, 0), 
     distance0=3, distance1=1
 )
@@ -108,7 +108,7 @@ The pin will be created on the position of the parent, which is the head of the
 Now we add a pin joint to close the kinematic loop.
 
 ```python
-pin = pl.Pivot(3, 2, joint0=crank, joint1=(3, 0), distance0=3, distance1=1)
+pin = pl.Revolute(3, 2, joint0=crank, joint1=(3, 0), distance0=3, distance1=1)
 ```
 
 In human language, here is what is happening:
@@ -127,7 +127,7 @@ then we keep the intersection closer to the previous position as the solution.
 Wait! A linkage with a single motor and only one pin joint? That doesn't make sense!
 : Behind the curtain, many joints are created on the fly. 
 When you define a ``Crank`` joint, it creates a motor **and** a pin joint on the crank's link head. 
-For a ``Pivot`` joint, it creates **3 pin joints**: one on each of its parents' positions, and one its position, 
+For a ``Revolute`` joint, it creates **3 pin joints**: one on each of its parents' positions, and one its position, 
 which forms a deformable triangle. 
 This is why pylinkage is so short to write.
 
@@ -159,7 +159,7 @@ import pylinkage as pl
 # Main motor
 crank = pl.Crank(0, 1, joint0=(0, 0), angle=.31, distance=1)
 # Close the loop
-pin = pl.Pivot(
+pin = pl.Revolute(
     3, 2, joint0=crank, joint1=(3, 0), 
     distance0=3, distance1=1
 )
@@ -195,7 +195,7 @@ Last recap, rearranging names:
 # Main motor
 crank = pl.Crank(0, 1, joint0=(0, 0), angle=.31, distance=1, name="B")
 # Close the loop
-pin = pl.Pivot(
+pin = pl.Revolute(
     3, 2, joint0=crank, joint1=(3, 0), 
     distance0=3, distance1=1, name="C"
 )
diff --git a/examples/fourbar_linkage.py b/examples/fourbar_linkage.py
index e1231a9..d2ecb85 100644
--- a/examples/fourbar_linkage.py
+++ b/examples/fourbar_linkage.py
@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-The fourbar_linkage module demonstrates the functionalities of pylinkage.
+The fourbar_linkage module demonstrates the features of pylinkage.
 
-It is not intended to be imported in another project, but fell welcome to
-copy-paste chunks of code.
+It is not intended to be imported in another project,
+but feel welcome to copy-paste chunks of code.
 
 Created on Sat Jun 19, 12:32:37 2021.
 
diff --git a/examples/inverted_stroke_engine.py b/examples/inverted_stroke_engine.py
new file mode 100644
index 0000000..9e008b2
--- /dev/null
+++ b/examples/inverted_stroke_engine.py
@@ -0,0 +1,18 @@
+"""
+An inverted four-stroke engine, that converts a rotary motion into a linear one.
+
+See: https://en.wikipedia.org/wiki/Four-stroke_engine for details
+"""
+import pylinkage as pl
+
+crank = pl.Crank(x=0, y=0, joint0=(0, 0), distance=1, angle=0.1, name="Crank")
+
+slider = pl.Linear(x=2, y=0, joint0=crank, joint1=(0, 0), joint2=(1, 0), revolute_radius=1.5, name="Slider")
+
+my_linkage = pl.Linkage(
+    joints=(crank, slider),
+    order=(crank, slider),
+    name="Simple four-stroke engine"
+)
+
+pl.show_linkage(my_linkage, duration=5)
diff --git a/examples/strider.py b/examples/strider.py
index 93a7925..6b4d584 100644
--- a/examples/strider.py
+++ b/examples/strider.py
@@ -1,12 +1,14 @@
 """
 Kinematic Strider linkage, a type of walking linkage.
 
-The original linkage can be found at https://www.diywalkers.com/strider-linkage-plans.html
+The original linkage can be found at
+https://www.diywalkers.com/strider-linkage-plans.html
 """
 
 import matplotlib.pyplot as plt
 import matplotlib.animation as anim
 import numpy as np
+
 import pylinkage as pl
 
 # Simulation parameters
@@ -22,13 +24,13 @@
 Units are given relative to crank length, which is normalized to 1.
 """
 DIM_NAMES = (
-    "triangle", "ape", "femur", "rockerL", "rockerS", "f", "tibia", "phi"
+    "triangle", "aperture", "femur", "rockerL", "rockerS", "f", "tibia", "phi"
 )
 
 DIMENSIONS = (
     # AB distance (=AB_p) "triangle":
     2,
-    # "ape":
+    # "aperture":
     np.pi / 4,
     # femur = 3 for higher steps, 2 for the standard size, but 1.8 is good enough
     1.8,
@@ -92,16 +94,17 @@ def param2dimensions(param=DIMENSIONS, flat=False):
 
 
 def complete_strider(constraints, prev):
-    """Take two sequences to define strider linkage.
+    """
+    Take two sequences to define strider linkage.
 
     :param constraints: The sequence of geometrical constraints.
     :type constraints: tuple[float] | tuple[tuple[float]]
     :param prev: Coordinates to set by default.
     :type prev: tuple[tuple[float, float]]
 
-    
+    :return pylinkage.Linkage: A strider linkage
     """
-    linka = {
+    linkage = {
         # Fixed points (mechanism body)
         # A is the origin
         "A": pl.Static(x=0, y=0, name="A"),
@@ -109,33 +112,33 @@ def complete_strider(constraints, prev):
         "Y": pl.Static(0, 1, name="Point (0, 1)"),
     }
     # For drawing only
-    linka["Y"].joint0 = linka["A"]
-    linka.update({
+    linkage["Y"].joint0 = linkage["A"]
+    linkage.update({
         # Not fixed because we will optimize this position
-        "B": pl.Fixed(joint0=linka["A"], joint1=linka["Y"], name="Frame right (B)"),
-        "B_p": pl.Fixed(joint0=linka["A"], joint1=linka["Y"], name="Frame left (B_p)"),
+        "B": pl.Fixed(joint0=linkage["A"], joint1=linkage["Y"], name="Frame right (B)"),
+        "B_p": pl.Fixed(joint0=linkage["A"], joint1=linkage["Y"], name="Frame left (B_p)"),
         # Pivot joints, explicitly defined to be modified later
         # Joint linked to crank. Coordinates are chosen in each frame
-        "C": pl.Crank(joint0=linka["A"], angle=-2 * np.pi / LAP_POINTS, name="Crank link (C)")
+        "C": pl.Crank(joint0=linkage["A"], angle=-2 * np.pi / LAP_POINTS, name="Crank link (C)")
     })
-    linka.update({
-        "D": pl.Revolute(joint0=linka["B_p"], joint1=linka["C"], name="Left knee link (D)"),
-        "E": pl.Revolute(joint0=linka["B"], joint1=linka["C"], name="Right knee link (E)")
+    linkage.update({
+        "D": pl.Revolute(joint0=linkage["B_p"], joint1=linkage["C"], name="Left knee link (D)"),
+        "E": pl.Revolute(joint0=linkage["B"], joint1=linkage["C"], name="Right knee link (E)")
     })
-    linka.update({
+    linkage.update({
         # F is fixed relative to C and E
-        "F": pl.Fixed(joint0=linka["C"], joint1=linka["E"], name='Left ankle link (F)'),
+        "F": pl.Fixed(joint0=linkage["C"], joint1=linkage["E"], name='Left ankle link (F)'),
         # G fixed to C and D
-        "G": pl.Fixed(joint0=linka["C"], joint1=linka["D"], name='Right ankle link (G)')
+        "G": pl.Fixed(joint0=linkage["C"], joint1=linkage["D"], name='Right ankle link (G)')
     })
-    linka.update({
-        "H": pl.Revolute(joint0=linka["D"], joint1=linka["F"], name="Left foot (H)"),
-        "I": pl.Revolute(joint0=linka["E"], joint1=linka["G"], name="Right foot (I)")
+    linkage.update({
+        "H": pl.Revolute(joint0=linkage["D"], joint1=linkage["F"], name="Left foot (H)"),
+        "I": pl.Revolute(joint0=linkage["E"], joint1=linkage["G"], name="Right foot (I)")
     })
     # Mechanism definition
     strider = pl.Linkage(
-        joints=linka.values(),
-        order=linka.values(),
+        joints=linkage.values(),
+        order=linkage.values(),
         name="Strider"
     )
     strider.set_coords(prev)
@@ -143,20 +146,20 @@ def complete_strider(constraints, prev):
     return strider
 
 
-def sym_stride_evaluator(linkage, dims, pos):
+def sym_stride_evaluator(linkage, dimensions, initial_positions):
     """Give score to each dimension set for symmetric strider.
 
     :param linkage: Input linkage
     :type linkage: pylinkage.Linkage
-    :param dims: Dimensions
-    :type dims: tuple
-    :param pos: Initial positions
-    :type pos: tuple
+    :param dimensions: Dimensions
+    :type dimensions: tuple
+    :param initial_positions: Initial positions
+    :type initial_positions: tuple
 
     :return: Score
     :rtype: float
     """
-    linkage.set_completely(param2dimensions(dims, flat=True), pos)
+    linkage.set_completely(param2dimensions(dimensions, flat=True), initial_positions)
     points = 12
     try:
         # Complete revolution with 12 points
@@ -194,21 +197,24 @@ def history_saver(evaluator, history, linkage, dims, pos):
 
 
 def view_swarm_polar(
-    linkage, dims=DIMENSIONS, save_each=0, age=300,
-    iters=400
+    linkage,
+    dimensions=DIMENSIONS,
+    save_each=0,
+    n_agents=300,
+    n_iterations=400
 ):
     """Draw an animation of the swarm in a polar graph.
 
     :param linkage: Input linkage
     :type linkage: pylinkage.Linkage
-    :param dims: Dimensions (Default value = DIMENSIONS)
-    :type dims: Sized
+    :param dimensions: Dimensions (Default value = DIMENSIONS)
+    :type dimensions: Sized
     :param save_each: To save the linkage state (Default value = 0)
     :type save_each: int | None
-    :param age: Number of agents (Default value = 300)
-    :type age: int
-    :param iters: NUmber of iterations (Default value = 400)
-    :type iters: int
+    :param n_agents: Number of agents (Default value = 300)
+    :type n_agents: int
+    :param n_iterations: NUmber of iterations (Default value = 400)
+    :type n_iterations: int
 
     
     """
@@ -216,14 +222,14 @@ def view_swarm_polar(
     out = pl.particle_swarm_optimization(
         lambda *x: history_saver(sym_stride_evaluator, history, *x),
         linkage,
-        center=dims, n_particles=age, iters=iters,
-        bounds=BOUNDS, dimensions=len(dims)
+        center=dimensions, n_particles=n_agents, iters=n_iterations,
+        bounds=BOUNDS, dimensions=len(dimensions)
     )
 
     fig = plt.figure(f"Swarm in polar graph")
     fig.suptitle(f"Final best score: {-out[0][0]:.2f}")
     formatted_history = [
-        history[i:i + age] for i in range(0, len(history), age)
+        history[i:i + n_agents] for i in range(0, len(history), n_agents)
     ]
     artists = []
 
@@ -231,14 +237,14 @@ def init_polar_repr():
         """Set the axis for the polar representation."""
         ax = fig.add_subplot(111, projection='polar')
         artists.extend(
-            [ax.plot([], [], lw=.5, animated=False)[0] for _ in range(age)]
+            ax.plot([], [], lw=.5, animated=False)[0] for _ in range(n_agents)
         )
         ax.set_rmax(7)
-        ax.set_xticklabels(DIM_NAMES + ("score",))
-        t = np.linspace(0, 2 * np.pi, len(dims) + 2)[:-1]
-        ax.set_xticks(t)
-        text = ax.text(1.9 * np.pi, 2, "", animated=True)
-        artists.append(text)
+        ax.set_xticks(
+            np.linspace(0, 2 * np.pi, len(dimensions) + 1, endpoint=False),
+            DIM_NAMES + ("score",)
+        )
+        artists.append(ax.text(1.9 * np.pi, 2, "", animated=True))
         return artists
 
     def repr_polar_swarm(current_swarm):
@@ -264,7 +270,7 @@ def repr_polar_swarm(current_swarm):
         init_func=init_polar_repr,
         blit=True,
         interval=400, repeat=True,
-        save_count=(iters - 1) * bool(save_each)
+        save_count=(n_iterations - 1) * bool(save_each)
     )
     plt.show()
     if save_each:
@@ -278,28 +284,35 @@ def repr_polar_swarm(current_swarm):
                 " set for Strider legged mechanism"
             }
         )
-        animation.save(r"PSO.mp4", writer=writer)
+        animation.save(
+            r"Particle Swarm Optimization of Strider linkage.mp4",
+            writer=writer
+        )
+    # Prevent the garbage-collection of the animation
     if animation:
         pass
     return out
 
 
 def view_swarm_tiled(
-    linkage, dims=DIMENSIONS, save_each=0, age=300,
-    iters=400
+    linkage,
+    dimensions=DIMENSIONS,
+    save_each=0,
+    n_agents=300,
+    n_iterations=400
 ):
     """Represent the final state of the best linkages.
 
     :param linkage: Linkage to edit
     :type linkage: Linkage
-    :param dims: Dimensions (Default value = DIMENSIONS)
-    :type dims: Sized
+    :param dimensions: Dimensions (Default value = DIMENSIONS)
+    :type dimensions: Sized
     :param save_each: Period of state save (Default value = 0)
     :type save_each: int | None
-    :param age: Number of agents (Default value = 300)
-    :type age: int
-    :param iters: NUmber of iterations (Default value = 400)
-    :type iters: int
+    :param n_agents: Number of agents (Default value = 300)
+    :type n_agents: int
+    :param n_iterations: NUmber of iterations (Default value = 400)
+    :type n_iterations: int
 
     
     """
@@ -308,18 +321,17 @@ def view_swarm_tiled(
     out = pl.particle_swarm_optimization(
         lambda *x: history_saver(sym_stride_evaluator, history, *x),
         linkage,
-        center=dims, n_particles=age, iters=iters,
-        bounds=BOUNDS, dimensions=len(dims)
+        center=dimensions, n_particles=n_agents, iters=n_iterations,
+        bounds=BOUNDS, dimensions=len(dimensions)
     )
 
     fig = plt.figure("Swarm in tiled mode")
-    cells = int(np.ceil(np.sqrt(age)))
+    cells = int(np.ceil(np.sqrt(n_agents)))
     axes = fig.subplots(cells, cells)
     formatted_history = [
-        history[i:i + age] for i in range(0, len(history), age)
+        history[i:i + n_agents] for i in range(0, len(history), n_agents)
     ]
 
-
     animation = anim.FuncAnimation(
         fig,
         lambda frame: pl.swarm_tiled_repr(
@@ -332,7 +344,7 @@ def view_swarm_tiled(
         frames=enumerate(formatted_history),
         blit=False,
         interval=1000, repeat=False,
-        save_count=(iters - 1) * bool(save_each)
+        save_count=(n_iterations - 1) * bool(save_each)
     )
     plt.show(block=not save_each)
     if save_each:
@@ -347,24 +359,32 @@ def view_swarm_tiled(
             }
         )
 
-        animation.save("Particle swarm optimization.mp4", writer=writer)
-    # Don't let the animation be garbage-collected!
+        animation.save(
+            "Strider linkage - Particle swarm optimization.mp4",
+            writer=writer
+        )
+    # Prevent the garbage-collection of the animation
     if animation:
         pass
     return out
 
 
 def swarm_optimizer(
-    linkage, dims=DIMENSIONS, show=False, save_each=0, age=300,
-    iters=400, *args
+    linkage,
+    dimensions=DIMENSIONS,
+    show=False,
+    save_each=0,
+    n_agents=300,
+    n_iterations=400,
+    *args,
 ):
     """Optimize linkage geometrically using PSO.
 
     :param linkage: The linkage to optimize.
     :type linkage: pylinkage.linkage.Linkage
-    :param dims: The dimensions that should vary.
+    :param dimensions: The dimensions that should vary.
     (Default value = DIMENSIONS).
-    :type dims: list[float]
+    :type dimensions: list[float]
     :param show: Type of visualization.
         - 0 for None
         - 1 for polar graph
@@ -373,33 +393,31 @@ def swarm_optimizer(
     :type show: int
     :param save_each: If show is 0, save the image each {save_each} frame. The default is 0.
     :type save_each: int
-    :param age: Number of agents to simulate. The default is 300.
-    :type age: int
-    :param iters: Number of iterations to run through. The default is 400.
-    :type iters: int
-    :param blind_ite: Number of iterations without evaluation. The default is 200.
-    :type blind_ite: int
-    :param *args: Arguments to pass to the particle swarm optimization.
-    :type *args: list
+    :param n_agents: Number of agents to simulate. The default is 300.
+    :type n_agents: int
+    :param n_iterations: Number of iterations to run through. The default is 400.
+    :type n_iterations: int
+    :param args: Arguments to pass to the particle swarm optimization.
+    :type args: list
 
     :return: List of fittest linkages.
     :rtype: list
     """
-    print("Initial dimensions:", dims)
+    print("Initial dimensions:", dimensions)
 
     if show == 1:
-        return view_swarm_polar(linkage, dims, save_each, age, iters)
+        return view_swarm_polar(linkage, dimensions, save_each, n_agents, n_iterations)
     elif show == 2:
         # Tiled representation of swarm
-        return view_swarm_tiled(linkage, dims, save_each, age, iters)
+        return view_swarm_tiled(linkage, dimensions, save_each, n_agents, n_iterations)
 
     if save_each:
         for dim, i in pl.particle_swarm_optimization(
             sym_stride_evaluator,
             linkage,
-            dimensions=len(dims),
-            n_particles=age,
-            iters=iters,
+            dimensions=len(dimensions),
+            n_particles=n_agents,
+            iters=n_iterations,
             bounds=BOUNDS
         ):
             if not i % save_each:
@@ -417,11 +435,11 @@ def swarm_optimizer(
         out = pl.particle_swarm_optimization(
             sym_stride_evaluator,
             linkage,
-            dims,
-            n_particles=age,
+            dimensions,
+            n_particles=n_agents,
             bounds=BOUNDS,
-            dimensions=len(dims),
-            iters=iters,
+            dimensions=len(dimensions),
+            iters=n_iterations,
             *args
         )
         return tuple(out)
@@ -453,9 +471,6 @@ def main():
     """Build and optimize a strider linkage.
     
     You can find it at https://www.diywalkers.com/strider-linkage-plans.html
-
-
-    
     """
     strider = complete_strider(param2dimensions(DIMENSIONS), INIT_COORD)
     print(
@@ -466,7 +481,7 @@ def main():
 
     # Particle swarm optimization
     optimized_striders = swarm_optimizer(
-        strider, show=1, save_each=0, age=40, iters=40
+        strider, show=1, save_each=0, n_agents=40, n_iterations=40
     )
     print(
         "Striding score after particle swarm optimization:",
diff --git a/pylinkage/__init__.py b/pylinkage/__init__.py
index b70e595..f5faf4f 100644
--- a/pylinkage/__init__.py
+++ b/pylinkage/__init__.py
@@ -24,12 +24,15 @@
     UnbuildableError,
     HypostaticError,
     Static,
-    Revolute,
     Pivot,
     Crank,
     Fixed,
     Linkage
 )
+from .joints import (
+    Linear,
+    Revolute,
+)
 from .optimization import (
     generate_bounds,
     trials_and_errors_optimization,
diff --git a/pylinkage/geometry.py b/pylinkage/geometry.py
index 3211b63..79b5a07 100644
--- a/pylinkage/geometry.py
+++ b/pylinkage/geometry.py
@@ -10,15 +10,16 @@
 @author: HugoFara
 """
 import math
+import warnings
 
 
 def dist_builtin(point1, point2):
     """Euclidian distance between two 2D points.
-    
+
     Legacy built-in unoptimized equivalent of math.dist in Python 3.8.
 
-    :param point1: 
-    :param point2: 
+    :param point1:
+    :param point2:
 
     """
     return math.sqrt(
@@ -34,21 +35,40 @@ def dist_builtin(point1, point2):
 
 
 def sqr_dist(point1, point2):
-    """Square of the distance between two points.
-    
+    """
+    Square of the distance between two points.
+
     Faster than dist.
 
-    :param point1: 
-    :param point2: 
+    :param tuple[float, float] point1: First point to compare
+    :param tuple[float, float] point2: Second point
 
+    :return float: Computed distance
     """
     return (point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2
 
 
+def get_nearest_point(reference_point, first_point, second_point):
+    """
+    Return the point closer to the reference.
+
+    :param tuple[float, float] reference_point: Point to compare to
+    :param tuple[float, float] first_point: First point candidate
+    :param tuple[float, float] second_point: Second point candidate
+    :return tuple[float, float]: Either first point or second point
+    """
+    if reference_point == first_point or reference_point == second_point:
+        return reference_point
+    if sqr_dist(reference_point, first_point) < sqr_dist(reference_point, second_point):
+        return first_point
+    return second_point
+
+
 def norm(vec):
     """
+    Return the norm of a 2-dimensional vector.
 
-    :param vec: 
+    :param vec:
 
     """
     return math.sqrt(vec[0] ** 2 + vec[1] ** 2)
@@ -65,8 +85,9 @@ def cyl_to_cart(radius, theta, ori=(0, 0)):
     return radius * math.cos(theta) + ori[0], radius * math.sin(theta) + ori[1]
 
 
-def __secant_circles_intersections__(distance, dist_x, dist_y, mid_dist,
-                                     radius1, projected):
+def secant_circles_intersections(
+        distance, dist_x, dist_y, mid_dist, radius1, projected
+    ):
     """Return the TWO intersections of secant circles."""
     # Distance between projected P and points
     # and the points of which P is projection
@@ -139,12 +160,110 @@ def circle_intersect(circle1, circle2, tol=0.0):
     )
 
     if dual:
-        return __secant_circles_intersections__(
+        return secant_circles_intersections(
             distance, dist_x, dist_y, mid_dist, radius1, projected
         )
     return 1, projected
 
 
+def line_from_points(first_point, second_point):
+    """
+    A cartesian equation of the line joining two points.
+
+    :param tuple[float, float] first_point: One point of the line.
+    :param tuple[float, float] second_point: Another point on the line.
+    :return tuple[float, float, float]: A cartesian equation of this line.
+    """
+    if first_point == second_point:
+        warnings.warn("Cannot choose a line, inputs points are the same!")
+        return 0, 0, 0
+    director = (
+        second_point[0] - first_point[0],
+        second_point[1] - first_point[1]
+    )
+    # The barycenter should give more precision
+    mean = (
+        (first_point[0] + second_point[0]) / 2,
+        (first_point[1] + second_point[1]) / 2
+    )
+    equilibrium = mean[0] * director[1] - mean[1] * director[0]
+    return -director[1], director[0], equilibrium
+
+
+def circle_line_from_points_intersection(circle, first_point, second_point):
+    """
+    Intersection(s) of a circle and a line defined by two points.
+
+    :param circle: Sequence of (abscissa, ordinate, radius)
+    :type circle: tuple[float, float, float]
+    :param tuple[float, float] first_point: One point of the line.
+    :param tuple[float, float] second_point: Another point on the line.
+
+    :return: Either 0, 1 or two intersection points, the first elements indicates the intersection type.
+    :rtype: tuple | tuple[tuple[float, float]] | tuple[tuple[float, float], tuple[float, float]]
+    """
+    # Move axis to circle center
+    first_point = first_point[0] - circle[0], first_point[1] - circle[1]
+    second_point = second_point[0] - circle[0], second_point[1] - circle[1]
+
+    dx, dy = second_point[0] - first_point[0], second_point[1] - first_point[1]
+
+    dr2 = dx ** 2 + dy ** 2
+
+    cross = first_point[0] * second_point[1] - second_point[0] * first_point[1]
+
+    discriminant = circle[2] ** 2 * dr2 - cross ** 2
+
+    if 0 > discriminant:
+        # no intersection
+        return tuple()
+
+    reduced = cross / dr2, math.sqrt(discriminant) / dr2
+
+    if discriminant == 0:
+        # Tangent line
+        return ((reduced[0] * dy + circle[0], -reduced[0] * dx + circle[1]), )
+
+    # discriminant > 0, two intersections
+    return (
+        (
+            reduced[0] * dy - (1 if dy >= 0 else -1) * dx * reduced[1] + circle[0],
+            -reduced[0] * dx - abs(dy) * reduced[1] + circle[1]
+        ),
+        (
+            reduced[0] * dy + (1 if dy >= 0 else -1) * dx * reduced[1] + circle[0],
+            -reduced[0] * dx + abs(dy) * reduced[1] + circle[1]
+        )
+    )
+
+
+def circle_line_intersection(circle, line):
+    """
+    Return the intersection between a line and a circle.
+
+    From https://mathworld.wolfram.com/Circle-LineIntersection.html
+
+    Circle((x0,y0), r).intersection(Line(a*x+b*y+c)) # sympy
+
+    :param circle: Sequence of (abscissa, ordinate, radius)
+    :type circle: tuple[float, float, float]
+    :param line: Cartesian equation of a line.
+    :type line: tuple[float, float, float]
+
+    :return: Nothing, one or two intersections. The length of the tuple gives the intersection type.
+    :rtype: tuple | tuple[tuple[float, float]] | tuple[tuple[float, float], tuple[float, float]]
+    """
+    # Find two points on the line
+    if line[1] != 0:
+        first_point = 0, - line[2] / line[1]
+        second_point = 1, - (line[2] + line[0]) / line[1]
+    else:
+        first_point = - line[2] / line[0], 0
+        second_point = - (line[2] + line[1]) / line[0], 1
+
+    return circle_line_from_points_intersection(circle, first_point, second_point)
+
+
 def intersection(obj_1, obj_2, tol=0.0):
     """Intersection of two arbitrary objects.
 
@@ -176,3 +295,29 @@ def intersection(obj_1, obj_2, tol=0.0):
     # Circle and point
     if len(obj_1) == 3 and len(obj_2) == 2:
         return intersection(obj_1=obj_2, obj_2=obj_1, tol=tol)
+
+
+def bounding_box(locus):
+    """
+    Compute the bounding box of a locus.
+
+    Parameters
+    ----------
+    locus : list[tuple[float]]
+        A list of point or any iterable with the same structure.
+
+    Returns
+    -------
+    tuple[float]
+        Bounding box as (y_min, x_max, y_max, x_min).
+    """
+    y_min = float('inf')
+    x_min = float('inf')
+    y_max = -float('inf')
+    x_max = -float('inf')
+    for point in locus:
+        y_min = min(y_min, point[1])
+        x_min = min(x_min, point[0])
+        y_max = max(y_max, point[1])
+        x_max = max(x_max, point[0])
+    return y_min, x_max, y_max, x_min
diff --git a/pylinkage/interface/__init__.py b/pylinkage/interface/__init__.py
index 2c82c62..ff844df 100644
--- a/pylinkage/interface/__init__.py
+++ b/pylinkage/interface/__init__.py
@@ -3,12 +3,13 @@
 """
 from .exceptions import (
     UnbuildableError,
-    HypostaticError
+    HypostaticError,
+    NotCompletelyDefinedError,
 )
 from .joint import (
     Static,
     Crank,
-    Fixed
+    Fixed,
 )
-from .revolute_joint import Revolute, Pivot
+from ..joints.revolute import Revolute, Pivot
 from .linkage import Linkage
diff --git a/pylinkage/interface/exceptions.py b/pylinkage/interface/exceptions.py
index 9cd3d7a..45499ec 100644
--- a/pylinkage/interface/exceptions.py
+++ b/pylinkage/interface/exceptions.py
@@ -31,8 +31,15 @@ def __str__(self):
 
 
 class HypostaticError(Exception):
-    """The system is under-constrained and multiple solutions may exist."""
+    """The linkage is under-constrained and multiple solutions may exist."""
 
-    def __init__(self, linkage, message='The system is hypo-static!'):
+    def __init__(self, linkage, message='The linkage is under-constrained!'):
         self.linkage = linkage
         super().__init__(message)
+
+
+class NotCompletelyDefinedError(Exception):
+    """The linkage definition is incomplete."""
+    def __init__(self, joint, message='The joint is not completely defined!'):
+        self.joint = joint
+        super().__init__(message)
diff --git a/pylinkage/interface/joint.py b/pylinkage/interface/joint.py
index 57671c7..8fccad9 100644
--- a/pylinkage/interface/joint.py
+++ b/pylinkage/interface/joint.py
@@ -3,12 +3,29 @@
 """
 import abc
 from math import atan2
+
 from ..geometry import cyl_to_cart
 from .exceptions import HypostaticError
 
 
+def joint_syntax_parser(joint):
+    """
+    Syntactic parser that understand a joint definition.
+
+    :param joint: Input joint definition to be parsed.
+    :type joint: Joint | tuple[float, float] | None
+
+    :return: New static joint definition if possible, or None.
+    :rtype: Static | None
+    """
+    if joint is None or isinstance(joint, Joint):
+        return joint
+    return Static(*joint)
+
+
 class Joint(abc.ABC):
-    """Geometric constraint expressed by two joints.
+    """
+    Geometric constraint expressed by two joints.
     
     Abstract class should always be inherited.
     """
@@ -17,30 +34,22 @@ class Joint(abc.ABC):
 
     def __init__(self, x=0, y=0, joint0=None, joint1=None, name=None):
         """
-        Create Joint.
-
-        Arguments
-        ---------
-        x : float, optional
-            Position on horizontal axis. The default is 0.
-        y : float, optional
-            Position on vertical axis. The default is O.
-        name : str, optional
-            Friendly name for human readability. The default is None.
-        joint0 : Union[Joint, tuple[float]], optional
-            Linked pivot joint 1 (geometric constraints). The default is None.
-        joint1 : Union[Joint, tuple[float]], optional
-            Other pivot joint linked. The default is None.
+        Create a Joint abstract object.
+
+        :param x: Position on horizontal axis. The default is 0.
+        :type x: float | None
+        :param y: Position on vertical axis. The default is O.
+        :type y: float | None
+        :param name: Friendly name for human readability. Will default to object if None.
+        :type name: str | None
+        :param joint0: First linked joint (geometric constraints). The default is None.
+        :type joint0: Joint | tuple[float, float] | None
+        :param joint1: Other revolute joint linked. The default is None.
+        :type joint1: Joint | tuple[float, float] | None
         """
         self.x, self.y = x, y
-        if joint0 is None or isinstance(joint0, Joint):
-            self.joint0 = joint0
-        else:
-            self.joint0 = Static(*joint0)
-        if joint1 is None or isinstance(joint1, Joint):
-            self.joint1 = joint1
-        else:
-            self.joint1 = Static(*joint1)
+        self.joint0 = joint_syntax_parser(joint0)
+        self.joint1 = joint_syntax_parser(joint1)
         self.name = name
         if name is None:
             self.name = str(id(self))
@@ -56,7 +65,11 @@ def __get_joints__(self):
         return self.joint0, self.joint1
 
     def coord(self):
-        """Return cartesian coordinates."""
+        """
+        Return cartesian coordinates.
+
+        :rtype: tuple[float | None, float | None]
+        """
         return self.x, self.y
 
     def set_coord(self, *args):
@@ -161,9 +174,9 @@ def __init__(self, x=None, y=None, joint0=None, joint1=None,
         name : str, optional
             Friendly name for human readability. The default is None.
         joint0 : Union[Joint, tuple[float]], optional
-            Linked pivot joint 1 (geometric constraints). The default is None.
+            Linked revolute joint 1 (geometric constraints). The default is None.
         joint1 : Union[Joint, tuple[float]], optional
-            Other pivot joint linked. The default is None.
+            Other revolute joint linked. The default is None.
         distance : float, optional
             Distance to keep constant between joint0 and self. The default is
             None.
@@ -233,8 +246,15 @@ class Crank(Joint):
 
     __slots__ = "r", "angle"
 
-    def __init__(self, x=None, y=None, joint0=None,
-                 distance=None, angle=None, name=None):
+    def __init__(
+        self,
+        x=None,
+        y=None,
+        joint0=None,
+        distance=None,
+        angle=None,
+        name=None
+    ):
         """
         Define a crank (circular motor).
 
@@ -267,7 +287,7 @@ def __init__(self, x=None, y=None, joint0=None,
     def reload(self, dt=1):
         """Make a step of crank.
 
-        :param dt: Fraction of step to do (Default value = 1)
+        :param dt: Fraction of steps to take (Default value = 1)
         :type dt: float
 
         """
diff --git a/pylinkage/interface/linkage.py b/pylinkage/interface/linkage.py
index 5033751..23921ba 100644
--- a/pylinkage/interface/linkage.py
+++ b/pylinkage/interface/linkage.py
@@ -15,7 +15,7 @@
     Crank,
     Fixed
 )
-from .revolute_joint import Revolute
+from ..joints import Revolute
 
 
 class Linkage:
@@ -138,7 +138,7 @@ def hyperstaticity(self):
                 kinematic_undetermined += 2
             elif isinstance(j, Revolute):
                 solids += 1
-                # A Pivot Joint creates at least two pivots
+                # A Revolute Joint creates at least two revolute joints
                 kinematic_undetermined += 4
                 if not hasattr(j, 'joint1') or j.joint1 is None:
                     mobilities += 1
diff --git a/pylinkage/joints/__init__.py b/pylinkage/joints/__init__.py
new file mode 100644
index 0000000..91e60fb
--- /dev/null
+++ b/pylinkage/joints/__init__.py
@@ -0,0 +1,6 @@
+"""Definition of joints."""
+
+from .linear import Linear
+from .revolute import Revolute
+
+from ..interface.joint import (Static, Fixed, Crank,)
diff --git a/pylinkage/joints/linear.py b/pylinkage/joints/linear.py
new file mode 100644
index 0000000..280c797
--- /dev/null
+++ b/pylinkage/joints/linear.py
@@ -0,0 +1,76 @@
+"""
+Definition of a linear joint.
+"""
+from ..interface import joint as pl_joint
+from ..interface import exceptions as pl_exceptions
+from .. import geometry as geom
+
+
+class Linear(pl_joint.Joint):
+    """Define a point constrained by a prismatic joint and a revolute joint."""
+
+    __slots__ = "revolute_radius", "joint2"
+
+    def __init__(
+        self,
+        x=0,
+        y=0,
+        joint0=None,
+        joint1=None,
+        joint2=None,
+        revolute_radius=None,
+        name=None
+    ):
+        """
+        Set point position, parents, and if it is fixed for this turn.
+
+        :param x: Position on horizontal axis. The default is 0.
+        :type x: float | None
+        :param y: Position on vertical axis. The default is 0.
+        :type y: float | None
+        :param joint0: Linked revolute joint 1 (geometric constraints). The default is None.
+        :type joint0: Joint | tuple[float, float]
+        :param joint1: First joint or point defining the axis. The default is None.
+        :type joint1: Joint | tuple[float, float]
+        :param joint2: Second joint or point defining the axis. The default is None.
+        :type joint2: Joint | tuple[float, float]
+        :param revolute_radius: Distance from joint0 to the current Joint. The default is None.
+        :type revolute_radius: float | None
+        :param name: Friendly name for human readability. The default is None.
+        :type name: str | None
+        """
+        super().__init__(x, y, joint0, joint1, name)
+        self.revolute_radius = revolute_radius
+        self.joint2 = pl_joint.joint_syntax_parser(joint2)
+
+    def reload(self):
+        """Compute position of revolute joint, with the three linked joints."""
+        if self.joint0 is None:
+            raise pl_exceptions.NotCompletelyDefinedError(self, "joint0 is not defined")
+        positions_circle = (*self.joint0.coord(), self.revolute_radius)
+        if None in positions_circle:
+            raise pl_exceptions.UnbuildableError(
+                self,
+                message="Joint has missing constraints. "
+                        "Current constraints are " + str(positions_circle)
+            )
+        positions = geom.circle_line_from_points_intersection(
+            positions_circle,
+            self.joint1.coord(),
+            self.joint2.coord()
+        )
+        if len(positions) == 0:
+            raise pl_exceptions.UnbuildableError(self)
+        elif len(positions) == 1:
+            self.x, self.y = positions[0]
+        else:
+            # Got to the nearest point
+            self.x, self.y = geom.get_nearest_point(self.coord(), positions[0], positions[1])
+
+    def get_constraints(self):
+        """Return the only distance constraint for this joint."""
+        return tuple([self.revolute_radius])
+
+    def set_constraints(self, distance0=None):
+        """Set the only distance constraint for this joint."""
+        self.revolute_radius = distance0 or self.revolute_radius
diff --git a/pylinkage/interface/revolute_joint.py b/pylinkage/joints/revolute.py
similarity index 82%
rename from pylinkage/interface/revolute_joint.py
rename to pylinkage/joints/revolute.py
index 11166ce..c6ac84e 100644
--- a/pylinkage/interface/revolute_joint.py
+++ b/pylinkage/joints/revolute.py
@@ -7,12 +7,12 @@
 import warnings
 from math import atan2
 
-from ..geometry import sqr_dist, circle_intersect, cyl_to_cart
-from .exceptions import UnbuildableError
-from .joint import Joint
+from .. import geometry as pl_geom
+from ..interface import exceptions as pl_exceptions
+from ..interface import joint as pl_joint
 
 
-class Revolute(Joint):
+class Revolute(pl_joint.Joint):
     """Center of a revolute joint."""
 
     __slots__ = "r0", "r1"
@@ -36,12 +36,12 @@ def __init__(
         :param y: Position on vertical axis.
             (Default value = 0).
         :type y: float
-        :param joint0: Linked pivot joint 0 (geometric constraints).
+        :param joint0: Linked revolute joint 0 (geometric constraints).
             (Default value = None).
-        :type joint0: Joint
-        :param joint1: Linked pivot joint 1 (geometric constraints).
+        :type joint0: Joint | tuple
+        :param joint1: Linked revolute joint 1 (geometric constraints).
             (Default value = None).
-        :type joint1: Joint
+        :type joint1: Joint | tuple
         :param distance0: Distance from joint0 to the current Joint.
             (Default value = None).
         :type distance0: float
@@ -88,45 +88,40 @@ def circle(self, joint):
         raise ValueError(f'{joint} is not in joints of {self}')
 
     def reload(self):
-        """Compute the position of pivot joint, use the two linked joints."""
+        """Compute the position of revolute joint, use the two linked joints."""
         if self.joint0 is None:
             return
         # Fixed joint as reference. In links, we only keep fixed objects
         ref = tuple(x for x in self.__get_joints__() if None not in x.coord())
         if len(ref) == 0:
-            # Don't modify coordinates (irrelevant)
+            # Don't change coordinates (irrelevant)
             return
         if len(ref) == 1:
             warnings.warn(
-                "Unable to set coordinates of pivot joint {}:"
+                "Unable to set coordinates of revolute joint {}:"
                 "Only one constraint is set."
                 "Coordinates unchanged".format(self.name)
             )
         elif len(ref) == 2:
             # Most common case, optimized here
-            coco = circle_intersect(
+            intersections = pl_geom.circle_intersect(
                 self.__get_joint_as_circle__(0),
                 self.__get_joint_as_circle__(1)
             )
-            if coco[0] == 0:
-                raise UnbuildableError(self)
-            if coco[0] == 1:
-                self.x, self.y = coco[1]
-            elif coco[0] == 2:
-                if sqr_dist(
-                        self.coord(), coco[1]
-                ) < sqr_dist(self.coord(), coco[2]):
-                    self.x, self.y = coco[1]
-                else:
-                    self.x, self.y = coco[2]
-            elif coco[0] == 3:
+            if intersections[0] == 0:
+                raise pl_exceptions.UnbuildableError(self)
+            if intersections[0] == 1:
+                self.x, self.y = intersections[1]
+            elif intersections[0] == 2:
+                self.x, self.y = pl_geom.get_nearest_point(self.coord(), intersections[1], intersections[2])
+            elif intersections[0] == 3:
                 warnings.warn(
                     f"Joint {self.name} has an infinite number of"
                     "solutions, position will be arbitrary"
                 )
                 # We project position on circle of possible positions
                 angle = atan2(self.y - self.joint0.y, self.x - self.joint0.x)
-                self.x, self.y = cyl_to_cart(self.r0, angle, self.joint0.coord())
+                self.x, self.y = pl_geom.cyl_to_cart(self.r0, angle, self.joint0.coord())
 
     def get_constraints(self):
         """Return the two constraining distances of this joint."""
@@ -163,8 +158,6 @@ def set_anchor1(self, joint, distance=None):
         :type joint: Joint | tuple[float]
         :param distance: Distance to keep constant from the anchor. The default is None.
         :type distance: float
-
-
         """
         self.joint1 = joint
         self.set_constraints(distance1=distance)
@@ -180,14 +173,14 @@ class Pivot(Revolute):
     """
 
     def __init__(
-            self,
-            x=0,
-            y=0,
-            joint0=None,
-            joint1=None,
-            distance0=None,
-            distance1=None,
-            name=None
+        self,
+        x=0,
+        y=0,
+        joint0=None,
+        joint1=None,
+        distance0=None,
+        distance1=None,
+        name=None
     ):
         """
         Set point position, parents, and if it is fixed for this turn.
diff --git a/pylinkage/optimization/particle_swarm.py b/pylinkage/optimization/particle_swarm.py
index 003b786..75ac078 100644
--- a/pylinkage/optimization/particle_swarm.py
+++ b/pylinkage/optimization/particle_swarm.py
@@ -68,8 +68,8 @@ def particle_swarm_optimization(
     :param kwargs: keyword arguments to pass to pyswarm.local.single.LocalBestPSO.
     :type kwargs: dict
 
-    :returns: List of 3 elements: best score, best dimensions and initial positions.
-    :rtype: Agent
+    :returns: List of Agents: best score, best dimensions and initial positions.
+    :rtype: List[Agent]
     """
     if dimensions is None:
         dimensions = len(tuple(linkage.get_num_constraints()))
diff --git a/pylinkage/utility.py b/pylinkage/utility.py
index 8a75d50..3250107 100644
--- a/pylinkage/utility.py
+++ b/pylinkage/utility.py
@@ -101,7 +101,7 @@ def bounding_box(locus):
     """Compute the bounding box of a locus.
 
     :param locus: A list of points or any iterable with the same structure.
-    :type locus: list[tuple[float]]
+    :type locus: list[tuple[float, float]] | tuple[tuple[float, float]]
 
     :returns: Bounding box as (y_min, x_max, y_max, x_min).
     :rtype: tuple[float, float, float, float]
diff --git a/pylinkage/visualizer.py b/pylinkage/visualizer.py
index 90d2164..8c823c8 100644
--- a/pylinkage/visualizer.py
+++ b/pylinkage/visualizer.py
@@ -11,7 +11,8 @@
 import matplotlib.animation as anim
 from .utility import movement_bounding_box
 from .interface.exceptions import UnbuildableError
-from .interface import Crank, Fixed, Static, Pivot, Revolute
+from .interface import Crank, Fixed, Static, Pivot
+from .joints import Revolute, Linear
 
 # List of animations
 ANIMATIONS = []
@@ -22,14 +23,15 @@
     Crank: 'g',
     Fixed: 'r',
     Pivot: 'b',
-    Revolute: 'b'
+    Revolute: 'b',
+    Linear: 'orange'
 }
 
 
 def _get_color(joint):
     """Search in COLOR_SWITCHER for the corresponding color.
 
-    :param joint: 
+    :param joint:
 
     """
     for joint_type, color in COLOR_SWITCHER.items():
@@ -56,7 +58,7 @@ def plot_static_linkage(
     :param show_legend: To add an automatic legend to the graph. The default is False.
     :type show_legend: bool
 
-    
+
     """
     axis.set_aspect('equal')
     axis.grid(True)
@@ -84,13 +86,20 @@ def plot_static_linkage(
             **plot_kwargs
         )
         # Then second parent
-        if isinstance(joint, (Crank, Static)):
-            continue
-        par_pos = joint.joint1.coord()
-        axis.plot(
-            [par_pos[0], pos[0]], [par_pos[1], pos[1]],
-            **plot_kwargs
-        )
+        if isinstance(joint, (Fixed, Pivot, Revolute)):
+            par_pos = joint.joint1.coord()
+            axis.plot(
+                [par_pos[0], pos[0]], [par_pos[1], pos[1]],
+                **plot_kwargs
+            )
+        elif isinstance(joint, Linear):
+            # Different ordering
+            par_pos = joint.joint2.coord()
+            other_pos = joint.joint1.coord()
+            axis.plot(
+                [par_pos[0], other_pos[0]], [par_pos[1], other_pos[1]],
+                **plot_kwargs
+            )
 
     # Highlight for specific loci
     if locus_highlights:
@@ -168,7 +177,7 @@ def plot_kinematic_linkage(
     :param interval: Delay between frames in milliseconds. The default is 40 (24 fps).
     :type interval: float
 
-    
+
     """
     axis.set_aspect('equal')
     axis.set_title("Animation")
@@ -187,8 +196,11 @@ def plot_kinematic_linkage(
         func=lambda index: update_animated_plot(
             linkage, index % len(loci), images, loci
         ),
-        frames=frames, blit=True, interval=interval, repeat=True,
-        save_count=frames)
+        frames=frames,
+        blit=True,
+        interval=interval,
+        repeat=True
+    )
     return animation
 
 
@@ -210,7 +222,7 @@ def show_linkage(
     :param save: To save the animation. The default is False.
     :type save: bool
     :param prev: Previous coordinates to use for linkage. The default is None.
-    :type prev: list
+    :type prev: list | tuple
     :param loci: list of loci. The default is None.
     :type loci: list
     :param points: Number of points to draw for a crank revolution.
@@ -228,7 +240,7 @@ def show_linkage(
         The default is 24.
     :type fps: int
 
-    
+
     """
     # Define initial positions
     linkage.rebuild(prev)
@@ -302,7 +314,7 @@ def swarm_tiled_repr(
         passing them to the linkage. (Default value = None)
     :type dimension_func: callable, optional
 
-    
+
     """
     fig.suptitle("Iteration: {}, best score: {}".format(swarm[0], max(agent[0] for agent in swarm[1])))
     for i, agent in enumerate(swarm[1]):
diff --git a/tests/test_collections.py b/tests/test_collections.py
index fc6fc09..4a5dfa2 100644
--- a/tests/test_collections.py
+++ b/tests/test_collections.py
@@ -11,11 +11,11 @@ def test_definition(self):
         dimensions = np.random.rand(np.random.randint(10))
         init_positions = np.random.rand(np.random.randint(10))
         agent = Agent(score, dimensions, init_positions)
-        self.assertEqual(agent.score, score)
-        self.assertTupleEqual(tuple(agent.dimensions), tuple(dimensions))
-        self.assertTupleEqual(tuple(agent.init_positions), tuple(init_positions))
+        self.assertEqual(score, agent.score)
+        self.assertTupleEqual(tuple(dimensions), tuple(agent.dimensions))
+        self.assertTupleEqual(tuple(init_positions), tuple(agent.init_positions))
         for i, val in enumerate([dimensions, init_positions]):
-            self.assertTupleEqual(tuple(agent[i + 1]), tuple(val))
+            self.assertTupleEqual(tuple(val), tuple(agent[i + 1]))
 
 
 class TestMutableAgent(unittest.TestCase):
@@ -27,10 +27,10 @@ def test_definition(self):
         init_positions = np.random.rand(np.random.randint(10))
         agent = MutableAgent(score, dimensions, init_positions)
         self.assertEqual(agent.score, score)
-        self.assertTupleEqual(tuple(agent.dimensions), tuple(dimensions))
-        self.assertTupleEqual(tuple(agent.init_positions), tuple(init_positions))
+        self.assertTupleEqual(tuple(dimensions), tuple(agent.dimensions))
+        self.assertTupleEqual(tuple(init_positions), tuple(agent.init_positions))
         for i, val in enumerate([dimensions, init_positions]):
-            self.assertTupleEqual(tuple(agent[i + 1]), tuple(val))
+            self.assertTupleEqual(tuple(val), tuple(agent[i + 1]))
 
     def test_assignment(self):
         """Assignment test of a MutableAgent object."""
@@ -42,7 +42,7 @@ def test_assignment(self):
             agent[i] = val
         self.assertEqual(agent[0], score)
         for i, val in enumerate([dimensions, init_positions]):
-            self.assertTupleEqual(tuple(agent[i + 1]), tuple(val))
+            self.assertTupleEqual(tuple(val), tuple(agent[i + 1]))
 
 
 if __name__ == '__main__':
diff --git a/tests/test_geometry.py b/tests/test_geometry.py
index a377f33..416456b 100644
--- a/tests/test_geometry.py
+++ b/tests/test_geometry.py
@@ -7,7 +7,9 @@
 """
 
 import unittest
-from pylinkage.geometry import circle_intersect
+import numpy as np
+
+from pylinkage.geometry import circle_intersect, circle_line_intersection, sqr_dist
 
 
 class TestCircles(unittest.TestCase):
@@ -15,19 +17,96 @@ class TestCircles(unittest.TestCase):
 
     def test_no_inter(self):
         """Test two circles not intersecting."""
-        c1 = (2., 5, 1)
-        c2 = (2, 5., 1.0)
+        c1 = 2., 5, 1
+        c2 = 2, 5., 1.0
         inter = circle_intersect(c1, c2)
-        self.assertEqual(len(inter), 2)
-        self.assertEqual(inter[0], 3)
+        self.assertEqual(2, len(inter))
+        self.assertEqual(3, inter[0])
 
     def test_radius_ineq(self):
         """Test two concentric circles of different radi."""
-        c1 = (2., 5, 1)
-        c2 = (2, 5., 1.4)
+        c1 = 2., 5, 1
+        c2 = 2, 5., 1.4
         inter = circle_intersect(c1, c2)
-        self.assertEqual(len(inter), 1)
-        self.assertEqual(inter[0], 0)
+        self.assertEqual(0, inter[0])
+
+
+def circle_line_intersection_data(mode):
+    """
+    Prepare the data for testing.
+
+    Arguments
+    ---------
+    mode : int
+        Desired number of intersections between the circle and the line.
+
+    Returns
+    -------
+    ((float, float, float), (float, float, float))
+        A circle and a line crossing {mode} times
+    """
+    circle = np.random.rand(3) * 10
+    circle[2] = abs(circle[2])
+    circle = (0, 0, 2)
+    # Put the first point on the circle
+    point = np.empty(2)
+    point[0] = circle[0] + (np.random.rand() * 2 - 1) * circle[2] * .9
+    point[1] = np.sqrt(circle[2] ** 2 - (point[0] - circle[0]) ** 2) + circle[1]
+    # Build a tangent line
+    line = np.empty(3)
+    vector = circle[:2] - point
+    line[:2] = vector
+    # Line is tangent
+    line[2] = -np.dot(line[:2], point)
+    if mode == 0:
+        line[2] += np.dot(
+            line[:2],
+            vector * circle[2] * (1 + np.random.rand())
+        )
+    if mode == 2:
+        line[2] -= np.dot(
+            line[:2],
+            vector * circle[2] * np.random.rand()
+        )
+    return circle, tuple(map(float, line))
+
+
+class TestCircleLineIntersection(unittest.TestCase):
+    """Various tests on straight line intersections."""
+
+    def test_no_crossing(self):
+        """Test a line and a circle not crossing each other."""
+        circle, line = circle_line_intersection_data(0)
+        intersection = circle_line_intersection(circle, tuple(line))
+        self.assertEqual(
+            0, len(intersection), f'Intersections: {intersection}:'
+        )
+
+    def test_tangent(self):
+        """
+        Test a straight line tangent to a circle.
+
+        This is a dangerous test, so we only want a success rate over 90%.
+        """
+        count = 0
+        for _ in range(20):
+            circle, line = circle_line_intersection_data(1)
+            intersection = circle_line_intersection(circle, line)
+            if len(intersection) == 1:
+                count += 1
+            elif len(intersection) == 2 and 1e-5 > sqr_dist(intersection[0], intersection[1]):
+                count += 1
+        self.assertLessEqual(
+            7, count, f"Success rate of {count * 5}% is too low!"
+        )
+
+    def test_crossing(self):
+        """Test a straight line crossing a circle twice."""
+        circle, line = circle_line_intersection_data(2)
+        intersection = circle_line_intersection(circle, tuple(line))
+        self.assertEqual(
+            2, len(intersection), f'Intersection: {intersection}:'
+        )
 
 
 if __name__ == '__main__':
diff --git a/tests/test_joints.py b/tests/test_joints.py
index 7769e8d..a55eec7 100644
--- a/tests/test_joints.py
+++ b/tests/test_joints.py
@@ -8,50 +8,51 @@
 
 import unittest
 import math
+
 from pylinkage import UnbuildableError
 from pylinkage.interface.joint import Fixed
-from pylinkage.interface.revolute_joint import Revolute, Pivot
+from pylinkage.joints import Revolute
 
 
 class TestPivot(unittest.TestCase):
     """Test Pivot Joint."""
 
-    pivot1 = Pivot(0, 0)
+    pivot1 = Revolute(0, 0)
 
     def test_buildable(self):
         """Upper intersect test."""
-        pivot2 = Pivot(1, 0)
-        pivot3 = Pivot(
+        pivot2 = Revolute(1, 0)
+        pivot3 = Revolute(
             y=1, joint0=self.pivot1, joint1=pivot2,
             distance0=1, distance1=1
         )
         pivot3.reload()
-        self.assertEqual(pivot3.coord(), (.5, math.sqrt(.75)))
+        self.assertEqual((.5, math.sqrt(.75)), pivot3.coord())
 
     def test_under_intersect(self):
         """Under intersect test."""
-        pivot2 = Pivot(1, 0)
-        pivot3 = Pivot(
+        pivot2 = Revolute(1, 0)
+        pivot3 = Revolute(
             y=-1, joint0=self.pivot1, joint1=pivot2,
             distance0=1, distance1=1
         )
         pivot3.reload()
-        self.assertEqual(pivot3.coord(), (.5, -math.sqrt(.75)))
+        self.assertEqual((.5, -math.sqrt(.75)), pivot3.coord())
 
     def test_limit_intersect(self):
         """Test system almost breaking."""
-        pivot2 = Pivot(2, 0)
-        pivot3 = Pivot(
+        pivot2 = Revolute(2, 0)
+        pivot3 = Revolute(
             y=1, joint0=self.pivot1, joint1=pivot2,
             distance0=1, distance1=1
         )
         pivot3.reload()
-        self.assertEqual(pivot3.coord(), (1, 0))
+        self.assertEqual((1, 0), pivot3.coord())
 
     def test_no_intersect(self):
         """Test system almost breaking."""
-        pivot2 = Pivot(0, 3)
-        pivot3 = Pivot(
+        pivot2 = Revolute(0, 3)
+        pivot3 = Revolute(
             y=1, joint0=self.pivot1, joint1=pivot2,
             distance0=1, distance1=1
         )
@@ -72,7 +73,7 @@ def test_buildable(self):
             distance0=1, distance1=1
         )
         pivot3.reload()
-        self.assertEqual(pivot3.coord(), (.5, math.sqrt(.75)))
+        self.assertEqual((.5, math.sqrt(.75)), pivot3.coord())
 
     def test_under_intersect(self):
         """Under intersect test."""
@@ -82,7 +83,7 @@ def test_under_intersect(self):
             distance0=1, distance1=1
         )
         pivot3.reload()
-        self.assertEqual(pivot3.coord(), (.5, -math.sqrt(.75)))
+        self.assertEqual((.5, -math.sqrt(.75)), pivot3.coord())
 
     def test_limit_intersect(self):
         """Test system almost breaking."""
@@ -92,7 +93,7 @@ def test_limit_intersect(self):
             distance0=1, distance1=1
         )
         pivot3.reload()
-        self.assertEqual(pivot3.coord(), (1, 0))
+        self.assertEqual((1, 0), pivot3.coord())
 
     def test_no_intersect(self):
         """Test system almost breaking."""
@@ -108,16 +109,16 @@ def test_no_intersect(self):
 class TestFixed(unittest.TestCase):
     """Test Fixed_Joint."""
 
-    pivot1 = Pivot(0, 0)
+    pivot1 = Revolute(0, 0)
 
     def test_pos(self):
         """Test Fixed_Joint positioning."""
-        pivot2 = Pivot(1, 0)
+        pivot2 = Revolute(1, 0)
         fixed = Fixed(
             joint0=self.pivot1, joint1=pivot2, angle=0, distance=1
         )
         fixed.reload()
-        self.assertEqual(fixed.coord(), (1, 0))
+        self.assertEqual((1, 0), fixed.coord())
 
 
 if __name__ == '__main__':
diff --git a/tests/test_linkage.py b/tests/test_linkage.py
index 1ecd535..4ecca0c 100644
--- a/tests/test_linkage.py
+++ b/tests/test_linkage.py
@@ -17,7 +17,7 @@ def __init__(self, method_name):
             name="B"
         )
         # Close the loop
-        self.pin = pl.Pivot(
+        self.pin = pl.Revolute(
             3, 2,
             joint0=self.crank, joint1=(3, 0),
             distance0=3, distance1=1, name="C"
@@ -31,7 +31,7 @@ def test_definition(self):
             order=[self.crank, self.pin],
             name="My four-bar linkage"
         )
-        self.assertTupleEqual(my_linkage.joints, (self.crank, self.pin))
+        self.assertTupleEqual((self.crank, self.pin), my_linkage.joints)
 
 
 if __name__ == '__main__':
diff --git a/tests/test_optimizer.py b/tests/test_optimizer.py
index 0e23ae3..d2a8f1c 100644
--- a/tests/test_optimizer.py
+++ b/tests/test_optimizer.py
@@ -17,7 +17,7 @@ def prepare_linkage():
     frame_first = pl.Static(0, 0)
     frame_second = pl.Static(3, 0)
     # Close the loop
-    pin = pl.Pivot(
+    pin = pl.Revolute(
         0, 2, joint0=frame_first, joint1=frame_second, distance0=3, distance1=1
     )
     # Linkage definition
@@ -28,8 +28,8 @@ def prepare_linkage():
 def fitness_func(loci, **kwargs):
     """Return if the tip can go to the point (3, 1).
 
-    :param loci: 
-    :param **kwargs: 
+    :param loci:
+    :param kwargs:
 
     .. notes
     It is a minimization problem.
@@ -60,7 +60,7 @@ class TestEvaluation(unittest.TestCase):
     def test_score(self):
         """Test if score is well returned."""
         score = fitness_func(self.linkage, self.constraints)
-        self.assertAlmostEqual(score, 1, delta=.1)
+        self.assertAlmostEqual(1, score, delta=.1)
 
 
 class TestVariator(unittest.TestCase):
@@ -97,7 +97,7 @@ def test_convergence(self):
             order_relation=min,
             verbose=False,
         )[0]
-        self.assertAlmostEqual(score, 0.0, delta=0.3)
+        self.assertAlmostEqual(0.0, score, delta=0.3)
 
 
 class TestPSO(unittest.TestCase):
@@ -128,7 +128,7 @@ def test_convergence(self):
             })
             score, dimensions, coord = optimization.particle_swarm_optimization(**opti_kwargs)[0]
         # Do not apply optimization problems
-        self.assertAlmostEqual(score, 0.0, delta=delta)
+        self.assertAlmostEqual(0.0, score, delta=delta)
 
 
 if __name__ == '__main__':