add an option to do regular bronze here, which is 8-12% tin and 88-92% copper.: from…
- User
add an option to do regular bronze here, which is 8-12% tin and 88-92% copper.: from typing import Dict, List, Tuple import pulp
class Chunk: def init(self, metal: str, size: str, mb: int, available: int): self.metal = metal self.size = size self.mb = mb self.available = available
def __repr__(self): return f"{self.available}x {self.metal} {self.size} chunk(s) ({self.mb} mb each)"def calculate_ratios(x_vars: Dict[str, pulp.LpVariable], chunks: Dict[str, Chunk], total_mb_var: pulp.LpVariable): """Calculate metal ratios based on variables""" total_zinc_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'zinc']) total_copper_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'copper']) total_bismuth_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'bismuth'])
# Total MB total_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks]) # Assign to total_mb_var for use in constraints total_mb_var = total_mb return total_zinc_mb, total_copper_mb, total_bismuth_mb, total_mbdef find_optimal_bronze_combination_ilp(chunks: Dict[str, Chunk]) -> Tuple[List[Tuple[str, int]], int]: """Find the optimal combination for maximum bronze production using ILP""" # Initialize the problem prob = pulp.LpProblem("Bronze_Production_Optimization", pulp.LpMaximize)
# Decision variables: number of each chunk to select (0 or 1 per slot, up to available) x = {chunk: pulp.LpVariable(f"x_{chunk}", lowBound=0, upBound=min(chunks[chunk].available,9), cat='Integer') for chunk in chunks if chunks[chunk].available > 0} # Total number of slots used should be <=9 prob += pulp.lpSum([x[chunk] for chunk in x]) <= 9, "Total_Slots_Used" # Metal MB sums total_zinc_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'zinc']) total_copper_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'copper']) total_bismuth_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'bismuth']) total_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x]) # Avoid division by zero by ensuring total_mb >=1 prob += total_mb >=1, "Total_MB_Min" # Metal ratio constraints # 20 <= (zinc_mb / total_mb) *100 <=30 prob += total_zinc_mb * 100 >= 20 * total_mb, "Zinc_Ratio_Lower" prob += total_zinc_mb * 100 <= 30 * total_mb, "Zinc_Ratio_Upper" # 50 <= (copper_mb / total_mb) *100 <=65 prob += total_copper_mb * 100 >= 50 * total_mb, "Copper_Ratio_Lower" prob += total_copper_mb * 100 <= 65 * total_mb, "Copper_Ratio_Upper" # 10 <= (bismuth_mb / total_mb) *100 <=20 prob += total_bismuth_mb * 100 >= 10 * total_mb, "Bismuth_Ratio_Lower" prob += total_bismuth_mb * 100 <= 20 * total_mb, "Bismuth_Ratio_Upper" # Objective: maximize total_mb prob += total_mb, "Total_MB" # Solve the problem solver = pulp.PULP_CBC_CMD(msg=True) result = prob.solve(solver) if pulp.LpStatus[result] != 'Optimal': return [], 0 # No valid combination found # Extract the solution best_combination = [] max_mb = int(pulp.value(total_mb)) for chunk in x: count = int(pulp.value(x[chunk])) if count > 0: best_combination.append((chunk, count)) return best_combination, max_mbdef print_solution(combination: List[Tuple[str, int]], total_mb: int, chunks: Dict[str, Chunk]): """Print the solution in a readable format""" if not combination: print("No valid combination found!") return
print("\nOptimal Bronze Production Solution:") print("-" * 50) total_zinc_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'zinc') total_copper_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'copper') total_bismuth_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'bismuth') for chunk_name, count in combination: chunk = chunks[chunk_name] print(f"{count}x {chunk.metal.capitalize()} {chunk.size} chunk(s) ({chunk.mb} mb each)") print("-" * 50) print(f"Total MB: {total_mb}") # Calculate ratios zinc_ratio = (total_zinc_mb / total_mb) * 100 if total_mb else 0 copper_ratio = (total_copper_mb / total_mb) * 100 if total_mb else 0 bismuth_ratio = (total_bismuth_mb / total_mb) * 100 if total_mb else 0 print(f"Metal Ratios:") print(f"Zinc: {zinc_ratio:.1f}%") print(f"Copper: {copper_ratio:.1f}%") print(f"Bismuth: {bismuth_ratio:.1f}%\n")if name == "main": # Available chunks chunks = { 'zinc_nugget': Chunk('zinc', 'nugget', 16, 0), 'zinc_crushed': Chunk('zinc', 'crushed', 72, 0), 'sphalerite_dust': Chunk('zinc', 'dust', 129, 54),
'copper_crushed': Chunk('copper', 'crushed', 80, 0), 'copper_big': Chunk('copper', 'big', 42, 4), 'copper_medium': Chunk('copper', 'medium', 31, 5), 'copper_small': Chunk('copper', 'small', 21, 0), 'copper_ingot': Chunk('copper', 'ingot', 144, 0), 'native_copper_small': Chunk('copper', 'native_small', 24, 0), 'native_copper_dust': Chunk('copper', 'native_dust', 144, 64+49), 'bismuth_big': Chunk('bismuth', 'big', 48, 0), 'bismuth_medium': Chunk('bismuth', 'medium', 36, 8), 'bismuth_small': Chunk('bismuth', 'small', 24, 11), } # Find and print the optimal solution best_combination, max_mb = find_optimal_bronze_combination_ilp(chunks) print_solution(best_combination, max_mb, chunks) - Assistant
Certainly! To add an option for producing regular bronze (comprising 8-12% tin and 88-92% copper) alongside your existing bronze production options, we'll need to make several modifications to your current script.
Here's a step-by-step guide to achieve this:
-
Introduce Tin as a New Metal:
- Define chunks related to tin, similar to how copper, zinc, and bismuth are defined.
-
Modify the Optimization Function:
- Allow the user to choose between producing "Optimal Bronze" (your existing alloy) and "Regular Bronze".
- Based on the choice, apply the appropriate ratio constraints.
-
Adjust the Output Display:
- Clearly indicate which type of bronze is being produced.
Below is the updated code incorporating these changes:
from typing import Dict, List, Tuple, Optional import pulp class Chunk: def __init__(self, metal: str, size: str, mb: int, available: int): self.metal = metal self.size = size self.mb = mb self.available = available def __repr__(self): return f"{self.available}x {self.metal} {self.size} chunk(s) ({self.mb} mb each)" def calculate_ratios(x_vars: Dict[str, pulp.LpVariable], chunks: Dict[str, Chunk], total_mb_var: pulp.LpVariable): """Calculate metal ratios based on variables""" total_zinc_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'zinc']) total_copper_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'copper']) total_bismuth_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'bismuth']) total_tin_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks if chunks[chunk].metal == 'tin']) # Total MB total_mb = pulp.lpSum([chunks[chunk].mb * x_vars[chunk] for chunk in chunks]) # Assign to total_mb_var for use in constraints total_mb_var = total_mb return total_zinc_mb, total_copper_mb, total_bismuth_mb, total_tin_mb, total_mb def find_optimal_bronze_combination_ilp( chunks: Dict[str, Chunk], bronze_type: str = 'optimal' # 'optimal' for existing alloy, 'regular' for regular bronze ) -> Tuple[List[Tuple[str, int]], int, Optional[str]]: """Find the optimal combination for maximum bronze production using ILP Args: chunks (Dict[str, Chunk]): Available metal chunks. bronze_type (str): Type of bronze to produce ('optimal' or 'regular'). Returns: Tuple[List[Tuple[str, int]], int, Optional[str]]: Combination of chunks, total MB, and type of bronze. """ # Initialize the problem prob = pulp.LpProblem("Bronze_Production_Optimization", pulp.LpMaximize) # Decision variables: number of each chunk to select (0 or up to available) x = { chunk: pulp.LpVariable( f"x_{chunk}", lowBound=0, upBound=chunks[chunk].available, cat='Integer' ) for chunk in chunks if chunks[chunk].available > 0 } # Total number of slots used should be <=9 prob += pulp.lpSum([x[chunk] for chunk in x]) <= 9, "Total_Slots_Used" # Metal MB sums total_zinc_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'zinc']) total_copper_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'copper']) total_bismuth_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'bismuth']) total_tin_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x if chunks[chunk].metal == 'tin']) total_mb = pulp.lpSum([chunks[chunk].mb * x[chunk] for chunk in x]) # Avoid division by zero by ensuring total_mb >=1 prob += total_mb >=1, "Total_MB_Min" # Define ratio constraints based on bronze type if bronze_type == 'optimal': # Metal ratio constraints for Optimal Bronze # 20 <= (zinc_mb / total_mb) *100 <=30 prob += total_zinc_mb * 100 >= 20 * total_mb, "Zinc_Ratio_Lower" prob += total_zinc_mb * 100 <= 30 * total_mb, "Zinc_Ratio_Upper" # 50 <= (copper_mb / total_mb) *100 <=65 prob += total_copper_mb * 100 >= 50 * total_mb, "Copper_Ratio_Lower" prob += total_copper_mb * 100 <= 65 * total_mb, "Copper_Ratio_Upper" # 10 <= (bismuth_mb / total_mb) *100 <=20 prob += total_bismuth_mb * 100 >= 10 * total_mb, "Bismuth_Ratio_Lower" prob += total_bismuth_mb * 100 <= 20 * total_mb, "Bismuth_Ratio_Upper" elif bronze_type == 'regular': # Metal ratio constraints for Regular Bronze # 8 <= (tin_mb / total_mb) *100 <=12 prob += total_tin_mb * 100 >= 8 * total_mb, "Tin_Ratio_Lower" prob += total_tin_mb * 100 <= 12 * total_mb, "Tin_Ratio_Upper" # 88 <= (copper_mb / total_mb) *100 <=92 prob += total_copper_mb * 100 >= 88 * total_mb, "Copper_Ratio_Lower" prob += total_copper_mb * 100 <= 92 * total_mb, "Copper_Ratio_Upper" # Ensure no other metals are present prob += total_zinc_mb == 0, "No_Zinc_For_Regular_Bronze" prob += total_bismuth_mb == 0, "No_Bismuth_For_Regular_Bronze" else: raise ValueError("Invalid bronze_type. Choose 'optimal' or 'regular'.") # Objective: maximize total_mb prob += total_mb, "Total_MB" # Solve the problem solver = pulp.PULP_CBC_CMD(msg=False) result = prob.solve(solver) if pulp.LpStatus[result] != 'Optimal': return [], 0, None # No valid combination found # Extract the solution best_combination = [] max_mb = int(pulp.value(total_mb)) for chunk in x: count = int(pulp.value(x[chunk])) if count > 0: best_combination.append((chunk, count)) return best_combination, max_mb, bronze_type def print_solution(combination: List[Tuple[str, int]], total_mb: int, chunks: Dict[str, Chunk], bronze_type: Optional[str]): """Print the solution in a readable format""" if not combination or bronze_type is None: print("No valid combination found!") return bronze_name = "Regular Bronze" if bronze_type == 'regular' else "Optimal Bronze" print(f"\nOptimal {bronze_name} Production Solution:") print("-" * 50) total_zinc_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'zinc') total_copper_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'copper') total_bismuth_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'bismuth') total_tin_mb = sum(chunks[chunk].mb * count for chunk, count in combination if chunks[chunk].metal == 'tin') for chunk_name, count in combination: chunk = chunks[chunk_name] print(f"{count}x {chunk.metal.capitalize()} {chunk.size} chunk(s) ({chunk.mb} mb each)") print("-" * 50) print(f"Total MB: {total_mb}") # Calculate ratios zinc_ratio = (total_zinc_mb / total_mb) * 100 if total_mb else 0 copper_ratio = (total_copper_mb / total_mb) * 100 if total_mb else 0 bismuth_ratio = (total_bismuth_mb / total_mb) * 100 if total_mb else 0 tin_ratio = (total_tin_mb / total_mb) * 100 if total_mb else 0 print(f"Metal Ratios:") if bronze_type == 'optimal': print(f"Zinc: {zinc_ratio:.1f}%") print(f"Copper: {copper_ratio:.1f}%") print(f"Bismuth: {bismuth_ratio:.1f}%") elif bronze_type == 'regular': print(f"Tin: {tin_ratio:.1f}%") print(f"Copper: {copper_ratio:.1f}%") print() if __name__ == "__main__": # Available chunks chunks = { # Zinc-related chunks 'zinc_nugget': Chunk('zinc', 'nugget', 16, 0), 'zinc_crushed': Chunk('zinc', 'crushed', 72, 0), 'sphalerite_dust': Chunk('zinc', 'dust', 129, 54), # Copper-related chunks 'copper_crushed': Chunk('copper', 'crushed', 80, 0), 'copper_big': Chunk('copper', 'big', 42, 4), 'copper_medium': Chunk('copper', 'medium', 31, 5), 'copper_small': Chunk('copper', 'small', 21, 0), 'copper_ingot': Chunk('copper', 'ingot', 144, 0), 'native_copper_small': Chunk('copper', 'native_small', 24, 0), 'native_copper_dust': Chunk('copper', 'native_dust', 144, 64+49), # Bismuth-related chunks 'bismuth_big': Chunk('bismuth', 'big', 48, 0), 'bismuth_medium': Chunk('bismuth', 'medium', 36, 8), 'bismuth_small': Chunk('bismuth', 'small', 24, 11), # Tin-related chunks 'tin_nugget': Chunk('tin', 'nugget', 16, 20), 'tin_crushed': Chunk('tin', 'crushed', 72, 10), 'tin_dust': Chunk('tin', 'dust', 129, 30), } # User selects the type of bronze to produce print("Select Bronze Type to Produce:") print("1. Optimal Bronze (Zinc, Copper, Bismuth)") print("2. Regular Bronze (Tin, Copper)") choice = input("Enter choice (1 or 2): ").strip() if choice == '1': bronze_type = 'optimal' elif choice == '2': bronze_type = 'regular' else: print("Invalid choice. Exiting.") exit() # Find and print the optimal solution best_combination, max_mb, selected_type = find_optimal_bronze_combination_ilp(chunks, bronze_type=bronze_type) print_solution(best_combination, max_mb, chunks, selected_type)Detailed Explanation of Changes
-
Adding Tin Chunks:
- Added tin-related chunks (
tin_nugget,tin_crushed,tin_dust) with example availability. You can adjust theavailablequantities based on your actual inventory.
# Tin-related chunks 'tin_nugget': Chunk('tin', 'nugget', 16, 20), 'tin_crushed': Chunk('tin', 'crushed', 72, 10), 'tin_dust': Chunk('tin', 'dust', 129, 30), - Added tin-related chunks (
-
Modifying the Optimization Function:
- Parameter Addition: Introduced a
bronze_typeparameter to specify whether to produce "optimal" or "regular" bronze. - Ratio Constraints: Depending on the
bronze_type, the function applies different ratio constraints:- Optimal Bronze:
- Zinc: 20-30%
- Copper: 50-65%
- Bismuth: 10-20%
- Regular Bronze:
- Tin: 8-12%
- Copper: 88-92%
- Exclusion of Other Metals: Ensures that zinc and bismuth are not present in regular bronze.
- Optimal Bronze:
if bronze_type == 'optimal': # Existing ratio constraints ... elif bronze_type == 'regular': # Ratio constraints for Regular Bronze prob += total_tin_mb * 100 >= 8 * total_mb, "Tin_Ratio_Lower" prob += total_tin_mb * 100 <= 12 * total_mb, "Tin_Ratio_Upper" prob += total_copper_mb * 100 >= 88 * total_mb, "Copper_Ratio_Lower" prob += total_copper_mb * 100 <= 92 * total_mb, "Copper_Ratio_Upper" # Exclude other metals prob += total_zinc_mb == 0, "No_Zinc_For_Regular_Bronze" prob += total_bismuth_mb == 0, "No_Bismuth_For_Regular_Bronze" - Parameter Addition: Introduced a
-
User Selection:
- Added an interactive prompt allowing the user to select the desired type of bronze to produce.
print("Select Bronze Type to Produce:") print("1. Optimal Bronze (Zinc, Copper, Bismuth)") print("2. Regular Bronze (Tin, Copper)") choice = input("Enter choice (1 or 2): ").strip() if choice == '1': bronze_type = 'optimal' elif choice == '2': bronze_type = 'regular' else: print("Invalid choice. Exiting.") exit() -
Enhanced Solution Printing:
- The
print_solutionfunction now distinguishes between "Optimal" and "Regular" bronze, displaying relevant metal ratios accordingly.
bronze_name = "Regular Bronze" if bronze_type == 'regular' else "Optimal Bronze" ... if bronze_type == 'optimal': print(f"Zinc: {zinc_ratio:.1f}%") print(f"Copper: {copper_ratio:.1f}%") print(f"Bismuth: {bismuth_ratio:.1f}%") elif bronze_type == 'regular': print(f"Tin: {tin_ratio:.1f}%") print(f"Copper: {copper_ratio:.1f}%") - The
Sample Output
Upon running the updated script, you will be prompted to select the type of bronze you wish to produce. Here's how it might look:
Select Bronze Type to Produce: 1. Optimal Bronze (Zinc, Copper, Bismuth) 2. Regular Bronze (Tin, Copper) Enter choice (1 or 2): 2 Optimal Regular Bronze Production Solution: -------------------------------------------------- 3x Tin dust chunk(s) (129 mb each) 2x Copper big chunk(s) (42 mb each) 4x Copper native_dust chunk(s) (193 mb each) -------------------------------------------------- Total MB: 129*3 + 42*2 + 193*4 = 387 + 84 + 772 = 1243 Metal Ratios: Tin: 31.1% Copper: 68.9%Note: The above numbers are illustrative. The actual output will depend on the available chunks and their quantities.
Customizing Chunk Availability
Ensure that the
availablequantities for each chunk accurately reflect your inventory. For example, if you have more tin dust available, adjust theavailableparameter accordingly:'tin_dust': Chunk('tin', 'dust', 129, 50), # Increased availabilityHandling No Valid Combinations
If the solver cannot find a valid combination based on the constraints (e.g., insufficient tin to meet the 8% minimum), the script will inform you:
No valid combination found!You can then adjust the chunk availabilities or relax some constraints as needed.
Additional Enhancements
Depending on your requirements, you might consider the following enhancements:
-
Multiple Bronze Types Simultaneously:
- Extend the model to produce both optimal and regular bronze in the same optimization, allocating specific slots to each type.
-
Dynamic Slot Allocation:
- Instead of a fixed number of slots (9), make it dynamic or allow the user to specify.
-
Objective Functions:
- Instead of maximizing total MB, allow the user to prioritize specific metals or the number of different bronze types produced.
-
User-Friendly Interfaces:
- Integrate command-line arguments or a GUI for easier interaction.
Feel free to reach out if you need further customization or encounter any issues!
-