#### Linear Diophantine Equations Solver

A
```package com.thealgorithms.maths;

import java.util.Objects;

public final class LinearDiophantineEquationsSolver {
private LinearDiophantineEquationsSolver() {
}

public static void main(String[] args) {
// 3x + 4y = 7
final var toSolve = new Equation(3, 4, 7);
System.out.println(findAnySolution(toSolve));
}

public static Solution findAnySolution(final Equation equation) {
if (equation.a() == 0 && equation.b() == 0 && equation.c() == 0) {
return Solution.INFINITE_SOLUTIONS;
}
final var stub = new GcdSolutionWrapper(0, new Solution(0, 0));
final var gcdSolution = gcd(equation.a(), equation.b(), stub);
if (equation.c() % gcdSolution.getGcd() != 0) {
return Solution.NO_SOLUTION;
}
final var toReturn = new Solution(0, 0);
var xToSet = stub.getSolution().getX() * (equation.c() / stub.getGcd());
var yToSet = stub.getSolution().getY() * (equation.c() / stub.getGcd());
toReturn.setX(xToSet);
toReturn.setY(yToSet);
}

private static GcdSolutionWrapper gcd(final int a, final int b, final GcdSolutionWrapper previous) {
if (b == 0) {
return new GcdSolutionWrapper(a, new Solution(1, 0));
}
// stub wrapper becomes the `previous` of the next recursive call
final var stubWrapper = new GcdSolutionWrapper(0, new Solution(0, 0));
final var next = /* recursive call */ gcd(b, a % b, stubWrapper);
previous.getSolution().setX(next.getSolution().getY());
previous.getSolution().setY(next.getSolution().getX() - (a / b) * (next.getSolution().getY()));
previous.setGcd(next.getGcd());
return new GcdSolutionWrapper(next.getGcd(), previous.getSolution());
}

public static final class Solution {

public static final Solution NO_SOLUTION = new Solution(Integer.MAX_VALUE, Integer.MAX_VALUE);
public static final Solution INFINITE_SOLUTIONS = new Solution(Integer.MIN_VALUE, Integer.MIN_VALUE);
private int x;
private int y;

public Solution(int x, int y) {
this.x = x;
this.y = y;
}

public int getX() {
return x;
}

public int getY() {
return y;
}

public void setX(int x) {
this.x = x;
}

public void setY(int y) {
this.y = y;
}

@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj == null || obj.getClass() != this.getClass()) {
return false;
}
var that = (Solution) obj;
return this.x == that.x && this.y == that.y;
}

@Override
public int hashCode() {
return Objects.hash(x, y);
}

@Override
public String toString() {
return "Solution["
+ "x=" + x + ", "
+ "y=" + y + ']';
}
}

public record Equation(int a, int b, int c) {
}

public static final class GcdSolutionWrapper {

private int gcd;
private Solution solution;

public GcdSolutionWrapper(int gcd, Solution solution) {
this.gcd = gcd;
this.solution = solution;
}

@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj == null || obj.getClass() != this.getClass()) {
return false;
}
var that = (GcdSolutionWrapper) obj;
return (this.gcd == that.gcd && Objects.equals(this.solution, that.solution));
}

public int getGcd() {
return gcd;
}

public void setGcd(int gcd) {
this.gcd = gcd;
}

public Solution getSolution() {
return solution;
}

public void setSolution(Solution solution) {
this.solution = solution;
}

@Override
public int hashCode() {
return Objects.hash(gcd, solution);
}

@Override
public String toString() {
return ("GcdSolutionWrapper["
+ "gcd=" + gcd + ", "
+ "solution=" + solution + ']');
}
}
}
```