From 3145aa0b3357fdca44a97f06ddc3fbd75d35f49f Mon Sep 17 00:00:00 2001 From: Carsten Otto Date: Sun, 27 Mar 2022 00:30:30 +0100 Subject: [PATCH] rename variables --- .../pickhardtpayments/ArcInitializer.java | 10 ++-- .../pickhardtpayments/MinCostFlowSolver.java | 4 +- .../MinCostFlowSolverTest.java | 60 +++++++++---------- 3 files changed, 37 insertions(+), 37 deletions(-) diff --git a/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/ArcInitializer.java b/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/ArcInitializer.java index 74953c97..f30749c0 100644 --- a/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/ArcInitializer.java +++ b/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/ArcInitializer.java @@ -33,9 +33,9 @@ class ArcInitializer { this.piecewiseLinearApproximations = piecewiseLinearApproximations; } - public void addArcs(Collection edgesWithCapacityInformation) { - Coins maximumCapacity = getMaximumCapacity(edgesWithCapacityInformation); - for (EdgeWithLiquidityInformation edgeWithLiquidityInformation : edgesWithCapacityInformation) { + public void addArcs(Collection edgesWithLiquidityInformation) { + Coins maximumCapacity = getMaximumCapacity(edgesWithLiquidityInformation); + for (EdgeWithLiquidityInformation edgeWithLiquidityInformation : edgesWithLiquidityInformation) { addArcs(edgeWithLiquidityInformation, maximumCapacity); } } @@ -62,8 +62,8 @@ class ArcInitializer { } } - private Coins getMaximumCapacity(Collection edgesWithCapacityInformation) { - return edgesWithCapacityInformation.stream() + private Coins getMaximumCapacity(Collection edgesWithLiquidityInformation) { + return edgesWithLiquidityInformation.stream() .map(EdgeWithLiquidityInformation::edge) .map(Edge::capacity) .max(Comparator.naturalOrder()) diff --git a/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolver.java b/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolver.java index 9da47462..e6c8ff8a 100644 --- a/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolver.java +++ b/pickhardt-payments/src/main/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolver.java @@ -32,7 +32,7 @@ class MinCostFlowSolver { } public MinCostFlowSolver( - Collection edgesWithCapacityInformation, + Collection edgesWithLiquidityInformation, Map sources, Map sinks, long quantization, @@ -46,7 +46,7 @@ class MinCostFlowSolver { quantization, piecewiseLinearApproximations ); - arcInitializer.addArcs(edgesWithCapacityInformation); + arcInitializer.addArcs(edgesWithLiquidityInformation); setSupply(sources, sinks); } diff --git a/pickhardt-payments/src/test/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolverTest.java b/pickhardt-payments/src/test/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolverTest.java index 31f1a901..f2cf8e47 100644 --- a/pickhardt-payments/src/test/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolverTest.java +++ b/pickhardt-payments/src/test/java/de/cotto/lndmanagej/pickhardtpayments/MinCostFlowSolverTest.java @@ -39,12 +39,12 @@ class MinCostFlowSolverTest { @Test void no_edge() { - Set edgesWithCapacityInformation = Set.of(); + Set edgesWithLiquidityInformation = Set.of(); Map sources = Map.of(PUBKEY, ONE_SAT); Map sinks = Map.of(PUBKEY_2, ONE_SAT); assertThatCode( () -> new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -55,13 +55,13 @@ class MinCostFlowSolverTest { @Test void no_sink_and_no_source() { - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE, ONE_SAT)); Map sources = Map.of(); Map sinks = Map.of(); assertThatCode( () -> new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -72,13 +72,13 @@ class MinCostFlowSolverTest { @Test void no_source() { - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, ONE_SAT)); Map sources = Map.of(); Map sinks = Map.of(PUBKEY_3, ONE_SAT); assertThatIllegalArgumentException().isThrownBy( () -> new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -89,13 +89,13 @@ class MinCostFlowSolverTest { @Test void no_sink() { - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, ONE_SAT)); Map sources = Map.of(PUBKEY_2, ONE_SAT); Map sinks = Map.of(); assertThatIllegalArgumentException().isThrownBy( () -> new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -106,13 +106,13 @@ class MinCostFlowSolverTest { @Test void sink_amount_does_not_match_source_amount() { - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE, ONE_SAT)); Map sources = Map.of(PUBKEY, ONE_SAT); Map sinks = Map.of(PUBKEY_2, TWO_SATS); assertThatIllegalArgumentException().isThrownBy( () -> new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -124,10 +124,10 @@ class MinCostFlowSolverTest { @Test void solve_simple() { Coins amount = Coins.ofSatoshis(PIECEWISE_LINEAR_APPROXIMATIONS); - List edgesWithCapacityInformation = + List edgesWithLiquidityInformation = List.of(EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, amount)); - Flows flows = solve(edgesWithCapacityInformation, PUBKEY_2, PUBKEY_3, amount); + Flows flows = solve(edgesWithLiquidityInformation, PUBKEY_2, PUBKEY_3, amount); assertThat(flows).isEqualTo(new Flows(FLOW_2_3)); } @@ -135,12 +135,12 @@ class MinCostFlowSolverTest { @Test void solve_no_solution_due_to_gap() { Coins amount = Coins.ofSatoshis(PIECEWISE_LINEAR_APPROXIMATIONS); - List edgesWithCapacityInformation = List.of( + List edgesWithLiquidityInformation = List.of( EdgeWithLiquidityInformation.forUpperBound(EDGE, amount), EdgeWithLiquidityInformation.forUpperBound(EDGE_3_4, amount) ); - Flows flows = solve(edgesWithCapacityInformation, PUBKEY, PUBKEY_4, amount); + Flows flows = solve(edgesWithLiquidityInformation, PUBKEY, PUBKEY_4, amount); assertThat(flows).isEqualTo(new Flows()); } @@ -149,13 +149,13 @@ class MinCostFlowSolverTest { void solve_with_quantization() { int quantization = 10_000; Coins amount = Coins.ofSatoshis(100_000); - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, amount)); Map sources = Map.of(PUBKEY_2, amount); Map sinks = Map.of(PUBKEY_3, amount); Flows flows = new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, quantization, @@ -169,13 +169,13 @@ class MinCostFlowSolverTest { void solve_with_quantization_but_requested_amount_not_divisible() { int quantization = 10_000; Coins amount = Coins.ofSatoshis(123_456); - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE_3_4, MANY_SATS)); Map sources = Map.of(PUBKEY_3, amount); Map sinks = Map.of(PUBKEY_4, amount); Flows flows = new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, quantization, @@ -188,13 +188,13 @@ class MinCostFlowSolverTest { @Test void quantization_larger_than_smallest_channel() { int quantization = 10_000; - Set edgesWithCapacityInformation = + Set edgesWithLiquidityInformation = Set.of(EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, ONE_SAT)); Map sources = Map.of(PUBKEY_2, ONE_SAT); Map sinks = Map.of(PUBKEY_3, ONE_SAT); Flows flows = new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, quantization, @@ -207,14 +207,14 @@ class MinCostFlowSolverTest { @Test void solve_two_sources_two_sinks() { Coins amount = Coins.ofSatoshis(PIECEWISE_LINEAR_APPROXIMATIONS); - List edgesWithCapacityInformation = List.of( + List edgesWithLiquidityInformation = List.of( EdgeWithLiquidityInformation.forUpperBound(EDGE, amount), EdgeWithLiquidityInformation.forUpperBound(EDGE_3_4, amount) ); Map sources = Map.of(PUBKEY, amount, PUBKEY_3, amount); Map sinks = Map.of(PUBKEY_2, amount, PUBKEY_4, amount); MinCostFlowSolver minCostFlowSolver = new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -226,14 +226,14 @@ class MinCostFlowSolverTest { @Test void solve_one_source_two_sinks() { - List edgesWithCapacityInformation = List.of( + List edgesWithLiquidityInformation = List.of( EdgeWithLiquidityInformation.forUpperBound(EDGE, ONE_SAT), EdgeWithLiquidityInformation.forUpperBound(EDGE_1_3, ONE_SAT) ); Map sources = Map.of(PUBKEY, TWO_SATS); Map sinks = Map.of(PUBKEY_2, ONE_SAT, PUBKEY_3, ONE_SAT); MinCostFlowSolver minCostFlowSolver = new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION, @@ -245,31 +245,31 @@ class MinCostFlowSolverTest { @Test void solve_long_path() { - List edgesWithCapacityInformation = List.of( + List edgesWithLiquidityInformation = List.of( EdgeWithLiquidityInformation.forUpperBound(EDGE, ONE_SAT), EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, MANY_SATS), EdgeWithLiquidityInformation.forUpperBound(EDGE_3_4, ONE_SAT) ); - Flows flows = solve(edgesWithCapacityInformation, PUBKEY, PUBKEY_4, ONE_SAT); + Flows flows = solve(edgesWithLiquidityInformation, PUBKEY, PUBKEY_4, ONE_SAT); assertThat(flows).isEqualTo(new Flows(FLOW_1_2, FLOW_2_3, FLOW_3_4)); } @Test void solve_long_path_with_cycle() { - List edgesWithCapacityInformation = List.of( + List edgesWithLiquidityInformation = List.of( EdgeWithLiquidityInformation.forUpperBound(EDGE, TWO_SATS), EdgeWithLiquidityInformation.forUpperBound(EDGE_2_3, MANY_SATS), EdgeWithLiquidityInformation.forUpperBound(EDGE_3_2, MANY_SATS), EdgeWithLiquidityInformation.forUpperBound(EDGE_3_4, TWO_SATS) ); - Flows flows = solve(edgesWithCapacityInformation, PUBKEY, PUBKEY_4, ONE_SAT); + Flows flows = solve(edgesWithLiquidityInformation, PUBKEY, PUBKEY_4, ONE_SAT); assertThat(flows).isEqualTo(new Flows(FLOW_1_2, FLOW_2_3, FLOW_3_4)); } private Flows solve( - List edgesWithCapacityInformation, + List edgesWithLiquidityInformation, Pubkey source, Pubkey target, Coins amount @@ -277,7 +277,7 @@ class MinCostFlowSolverTest { Map sources = Map.of(source, amount); Map sinks = Map.of(target, amount); return new MinCostFlowSolver( - edgesWithCapacityInformation, + edgesWithLiquidityInformation, sources, sinks, QUANTIZATION,