From 3706270589f82ea4455eea43a48c9c7c4f77edc3 Mon Sep 17 00:00:00 2001 From: FiveMovesAhead Date: Thu, 16 Jan 2025 21:04:08 +0000 Subject: [PATCH] Compiled knapsack/knapsplorify --- .../knapsplorify/benchmarker_outbound.rs | 140 ++++++++++++++++++ .../src/knapsack/knapsplorify/commercial.rs | 140 ++++++++++++++++++ .../src/knapsack/knapsplorify/inbound.rs | 140 ++++++++++++++++++ .../knapsplorify/innovator_outbound.rs | 140 ++++++++++++++++++ .../src/knapsack/knapsplorify/mod.rs | 4 + .../src/knapsack/knapsplorify/open_data.rs | 140 ++++++++++++++++++ tig-algorithms/src/knapsack/mod.rs | 3 +- tig-algorithms/src/knapsack/template.rs | 26 +--- .../wasm/knapsack/knapsplorify.wasm | Bin 0 -> 156848 bytes 9 files changed, 708 insertions(+), 25 deletions(-) create mode 100644 tig-algorithms/src/knapsack/knapsplorify/benchmarker_outbound.rs create mode 100644 tig-algorithms/src/knapsack/knapsplorify/commercial.rs create mode 100644 tig-algorithms/src/knapsack/knapsplorify/inbound.rs create mode 100644 tig-algorithms/src/knapsack/knapsplorify/innovator_outbound.rs create mode 100644 tig-algorithms/src/knapsack/knapsplorify/mod.rs create mode 100644 tig-algorithms/src/knapsack/knapsplorify/open_data.rs create mode 100644 tig-algorithms/wasm/knapsack/knapsplorify.wasm diff --git a/tig-algorithms/src/knapsack/knapsplorify/benchmarker_outbound.rs b/tig-algorithms/src/knapsack/knapsplorify/benchmarker_outbound.rs new file mode 100644 index 00000000..df056a9b --- /dev/null +++ b/tig-algorithms/src/knapsack/knapsplorify/benchmarker_outbound.rs @@ -0,0 +1,140 @@ +/*! +Copyright 2014 stanlocht + +Licensed under the TIG Benchmarker Outbound Game License v1.0 (the "License"); you +may not use this file except in compliance with the License. You may obtain a copy +of the License at + +https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses + +Unless required by applicable law or agreed to in writing, software distributed +under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied. See the License for the specific +language governing permissions and limitations under the License. +*/ + +// TIG's UI uses the pattern `tig_challenges::` to automatically detect your algorithm's challenge +use anyhow::{anyhow, Result}; +use tig_challenges::knapsack::{Challenge, Solution}; + +#[derive(Clone, PartialEq)] +struct Node { + level: usize, + profit: usize, + weight: usize, + bound: f64, + items: Vec, +} + +impl Node { + fn new(level: usize, profit: usize, weight: usize, bound: f64, items: Vec) -> Self { + Self { level, profit, weight, bound, items } + } +} + +pub fn solve_challenge(challenge: &Challenge) -> Result> { + let maximum_weight_capacity = challenge.max_weight as usize; + let minimum_value_required = challenge.min_value as usize; + let number_of_items = challenge.difficulty.num_items; + + let item_weights: Vec = challenge.weights.iter().map(|&weight| weight as usize).collect(); + let item_values: Vec = challenge.values.iter().map(|&value| value as usize).collect(); + + let mut items_sorted_by_value_density: Vec<(usize, f64)> = (0..number_of_items) + .map(|item_index| (item_index, item_values[item_index] as f64 / item_weights[item_index] as f64)) + .collect(); + items_sorted_by_value_density.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + + fn calculate_bound(node: &Node, maximum_weight_capacity: usize, items_sorted_by_value_density: &[(usize, f64)], item_weights: &[usize], item_values: &[usize]) -> f64 { + if node.weight >= maximum_weight_capacity { + return 0.0; + } + + let mut bound = node.profit as f64; + let mut total_weight = node.weight; + let mut j = node.level; + + while j < items_sorted_by_value_density.len() && total_weight + item_weights[items_sorted_by_value_density[j].0] <= maximum_weight_capacity { + total_weight += item_weights[items_sorted_by_value_density[j].0]; + bound += item_values[items_sorted_by_value_density[j].0] as f64; + j += 1; + } + + if j < items_sorted_by_value_density.len() { + bound += (maximum_weight_capacity - total_weight) as f64 * items_sorted_by_value_density[j].1; + } + + bound + } + + let mut max_profit = 0; + let mut best_items = Vec::new(); + let mut nodes = vec![Node::new(0, 0, 0, 0.0, Vec::new())]; + nodes[0].bound = calculate_bound(&nodes[0], maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + while let Some(node) = nodes.pop() { + if node.bound > max_profit as f64 && node.level < number_of_items { + let next_level = node.level + 1; + + // Explore the node including the next item + let next_item_index = items_sorted_by_value_density[node.level].0; + let next_weight = node.weight + item_weights[next_item_index]; + let next_profit = node.profit + item_values[next_item_index]; + + let mut include_items = node.items.clone(); + include_items.push(next_item_index); + + if next_weight <= maximum_weight_capacity && next_profit > max_profit { + max_profit = next_profit; + best_items = include_items.clone(); + } + + let mut include_node = Node::new(next_level, next_profit, next_weight, 0.0, include_items); + include_node.bound = calculate_bound(&include_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if include_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&include_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, include_node); + } + + // Explore the node excluding the next item + let mut exclude_node = Node::new(next_level, node.profit, node.weight, 0.0, node.items.clone()); + exclude_node.bound = calculate_bound(&exclude_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if exclude_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&exclude_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, exclude_node); + } + } + } + + if max_profit >= minimum_value_required { + Ok(Some(Solution { items: best_items })) + } else { + Ok(None) + } +} + +// Important! Do not include any tests in this file, it will result in your submission being rejected + +#[cfg(feature = "cuda")] +mod gpu_optimisation { + use super::*; + use cudarc::driver::*; + use std::{collections::HashMap, sync::Arc}; + use tig_challenges::CudaKernel; + + // set KERNEL to None if algorithm only has a CPU implementation + pub const KERNEL: Option = None; + + // Important! your GPU and CPU version of the algorithm should return the same result + pub fn cuda_solve_challenge( + challenge: &Challenge, + dev: &Arc, + mut funcs: HashMap<&'static str, CudaFunction>, + ) -> anyhow::Result> { + solve_challenge(challenge) + } +} +#[cfg(feature = "cuda")] +pub use gpu_optimisation::{cuda_solve_challenge, KERNEL}; diff --git a/tig-algorithms/src/knapsack/knapsplorify/commercial.rs b/tig-algorithms/src/knapsack/knapsplorify/commercial.rs new file mode 100644 index 00000000..f39dbe36 --- /dev/null +++ b/tig-algorithms/src/knapsack/knapsplorify/commercial.rs @@ -0,0 +1,140 @@ +/*! +Copyright 2014 stanlocht + +Licensed under the TIG Commercial License v1.0 (the "License"); you +may not use this file except in compliance with the License. You may obtain a copy +of the License at + +https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses + +Unless required by applicable law or agreed to in writing, software distributed +under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied. See the License for the specific +language governing permissions and limitations under the License. +*/ + +// TIG's UI uses the pattern `tig_challenges::` to automatically detect your algorithm's challenge +use anyhow::{anyhow, Result}; +use tig_challenges::knapsack::{Challenge, Solution}; + +#[derive(Clone, PartialEq)] +struct Node { + level: usize, + profit: usize, + weight: usize, + bound: f64, + items: Vec, +} + +impl Node { + fn new(level: usize, profit: usize, weight: usize, bound: f64, items: Vec) -> Self { + Self { level, profit, weight, bound, items } + } +} + +pub fn solve_challenge(challenge: &Challenge) -> Result> { + let maximum_weight_capacity = challenge.max_weight as usize; + let minimum_value_required = challenge.min_value as usize; + let number_of_items = challenge.difficulty.num_items; + + let item_weights: Vec = challenge.weights.iter().map(|&weight| weight as usize).collect(); + let item_values: Vec = challenge.values.iter().map(|&value| value as usize).collect(); + + let mut items_sorted_by_value_density: Vec<(usize, f64)> = (0..number_of_items) + .map(|item_index| (item_index, item_values[item_index] as f64 / item_weights[item_index] as f64)) + .collect(); + items_sorted_by_value_density.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + + fn calculate_bound(node: &Node, maximum_weight_capacity: usize, items_sorted_by_value_density: &[(usize, f64)], item_weights: &[usize], item_values: &[usize]) -> f64 { + if node.weight >= maximum_weight_capacity { + return 0.0; + } + + let mut bound = node.profit as f64; + let mut total_weight = node.weight; + let mut j = node.level; + + while j < items_sorted_by_value_density.len() && total_weight + item_weights[items_sorted_by_value_density[j].0] <= maximum_weight_capacity { + total_weight += item_weights[items_sorted_by_value_density[j].0]; + bound += item_values[items_sorted_by_value_density[j].0] as f64; + j += 1; + } + + if j < items_sorted_by_value_density.len() { + bound += (maximum_weight_capacity - total_weight) as f64 * items_sorted_by_value_density[j].1; + } + + bound + } + + let mut max_profit = 0; + let mut best_items = Vec::new(); + let mut nodes = vec![Node::new(0, 0, 0, 0.0, Vec::new())]; + nodes[0].bound = calculate_bound(&nodes[0], maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + while let Some(node) = nodes.pop() { + if node.bound > max_profit as f64 && node.level < number_of_items { + let next_level = node.level + 1; + + // Explore the node including the next item + let next_item_index = items_sorted_by_value_density[node.level].0; + let next_weight = node.weight + item_weights[next_item_index]; + let next_profit = node.profit + item_values[next_item_index]; + + let mut include_items = node.items.clone(); + include_items.push(next_item_index); + + if next_weight <= maximum_weight_capacity && next_profit > max_profit { + max_profit = next_profit; + best_items = include_items.clone(); + } + + let mut include_node = Node::new(next_level, next_profit, next_weight, 0.0, include_items); + include_node.bound = calculate_bound(&include_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if include_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&include_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, include_node); + } + + // Explore the node excluding the next item + let mut exclude_node = Node::new(next_level, node.profit, node.weight, 0.0, node.items.clone()); + exclude_node.bound = calculate_bound(&exclude_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if exclude_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&exclude_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, exclude_node); + } + } + } + + if max_profit >= minimum_value_required { + Ok(Some(Solution { items: best_items })) + } else { + Ok(None) + } +} + +// Important! Do not include any tests in this file, it will result in your submission being rejected + +#[cfg(feature = "cuda")] +mod gpu_optimisation { + use super::*; + use cudarc::driver::*; + use std::{collections::HashMap, sync::Arc}; + use tig_challenges::CudaKernel; + + // set KERNEL to None if algorithm only has a CPU implementation + pub const KERNEL: Option = None; + + // Important! your GPU and CPU version of the algorithm should return the same result + pub fn cuda_solve_challenge( + challenge: &Challenge, + dev: &Arc, + mut funcs: HashMap<&'static str, CudaFunction>, + ) -> anyhow::Result> { + solve_challenge(challenge) + } +} +#[cfg(feature = "cuda")] +pub use gpu_optimisation::{cuda_solve_challenge, KERNEL}; diff --git a/tig-algorithms/src/knapsack/knapsplorify/inbound.rs b/tig-algorithms/src/knapsack/knapsplorify/inbound.rs new file mode 100644 index 00000000..58bd392b --- /dev/null +++ b/tig-algorithms/src/knapsack/knapsplorify/inbound.rs @@ -0,0 +1,140 @@ +/*! +Copyright 2014 stanlocht + +Licensed under the TIG Inbound Game License v1.0 or (at your option) any later +version (the "License"); you may not use this file except in compliance with the +License. You may obtain a copy of the License at + +https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses + +Unless required by applicable law or agreed to in writing, software distributed +under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied. See the License for the specific +language governing permissions and limitations under the License. +*/ + +// TIG's UI uses the pattern `tig_challenges::` to automatically detect your algorithm's challenge +use anyhow::{anyhow, Result}; +use tig_challenges::knapsack::{Challenge, Solution}; + +#[derive(Clone, PartialEq)] +struct Node { + level: usize, + profit: usize, + weight: usize, + bound: f64, + items: Vec, +} + +impl Node { + fn new(level: usize, profit: usize, weight: usize, bound: f64, items: Vec) -> Self { + Self { level, profit, weight, bound, items } + } +} + +pub fn solve_challenge(challenge: &Challenge) -> Result> { + let maximum_weight_capacity = challenge.max_weight as usize; + let minimum_value_required = challenge.min_value as usize; + let number_of_items = challenge.difficulty.num_items; + + let item_weights: Vec = challenge.weights.iter().map(|&weight| weight as usize).collect(); + let item_values: Vec = challenge.values.iter().map(|&value| value as usize).collect(); + + let mut items_sorted_by_value_density: Vec<(usize, f64)> = (0..number_of_items) + .map(|item_index| (item_index, item_values[item_index] as f64 / item_weights[item_index] as f64)) + .collect(); + items_sorted_by_value_density.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + + fn calculate_bound(node: &Node, maximum_weight_capacity: usize, items_sorted_by_value_density: &[(usize, f64)], item_weights: &[usize], item_values: &[usize]) -> f64 { + if node.weight >= maximum_weight_capacity { + return 0.0; + } + + let mut bound = node.profit as f64; + let mut total_weight = node.weight; + let mut j = node.level; + + while j < items_sorted_by_value_density.len() && total_weight + item_weights[items_sorted_by_value_density[j].0] <= maximum_weight_capacity { + total_weight += item_weights[items_sorted_by_value_density[j].0]; + bound += item_values[items_sorted_by_value_density[j].0] as f64; + j += 1; + } + + if j < items_sorted_by_value_density.len() { + bound += (maximum_weight_capacity - total_weight) as f64 * items_sorted_by_value_density[j].1; + } + + bound + } + + let mut max_profit = 0; + let mut best_items = Vec::new(); + let mut nodes = vec![Node::new(0, 0, 0, 0.0, Vec::new())]; + nodes[0].bound = calculate_bound(&nodes[0], maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + while let Some(node) = nodes.pop() { + if node.bound > max_profit as f64 && node.level < number_of_items { + let next_level = node.level + 1; + + // Explore the node including the next item + let next_item_index = items_sorted_by_value_density[node.level].0; + let next_weight = node.weight + item_weights[next_item_index]; + let next_profit = node.profit + item_values[next_item_index]; + + let mut include_items = node.items.clone(); + include_items.push(next_item_index); + + if next_weight <= maximum_weight_capacity && next_profit > max_profit { + max_profit = next_profit; + best_items = include_items.clone(); + } + + let mut include_node = Node::new(next_level, next_profit, next_weight, 0.0, include_items); + include_node.bound = calculate_bound(&include_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if include_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&include_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, include_node); + } + + // Explore the node excluding the next item + let mut exclude_node = Node::new(next_level, node.profit, node.weight, 0.0, node.items.clone()); + exclude_node.bound = calculate_bound(&exclude_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if exclude_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&exclude_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, exclude_node); + } + } + } + + if max_profit >= minimum_value_required { + Ok(Some(Solution { items: best_items })) + } else { + Ok(None) + } +} + +// Important! Do not include any tests in this file, it will result in your submission being rejected + +#[cfg(feature = "cuda")] +mod gpu_optimisation { + use super::*; + use cudarc::driver::*; + use std::{collections::HashMap, sync::Arc}; + use tig_challenges::CudaKernel; + + // set KERNEL to None if algorithm only has a CPU implementation + pub const KERNEL: Option = None; + + // Important! your GPU and CPU version of the algorithm should return the same result + pub fn cuda_solve_challenge( + challenge: &Challenge, + dev: &Arc, + mut funcs: HashMap<&'static str, CudaFunction>, + ) -> anyhow::Result> { + solve_challenge(challenge) + } +} +#[cfg(feature = "cuda")] +pub use gpu_optimisation::{cuda_solve_challenge, KERNEL}; diff --git a/tig-algorithms/src/knapsack/knapsplorify/innovator_outbound.rs b/tig-algorithms/src/knapsack/knapsplorify/innovator_outbound.rs new file mode 100644 index 00000000..2d0fa38a --- /dev/null +++ b/tig-algorithms/src/knapsack/knapsplorify/innovator_outbound.rs @@ -0,0 +1,140 @@ +/*! +Copyright 2014 stanlocht + +Licensed under the TIG Innovator Outbound Game License v1.0 (the "License"); you +may not use this file except in compliance with the License. You may obtain a copy +of the License at + +https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses + +Unless required by applicable law or agreed to in writing, software distributed +under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied. See the License for the specific +language governing permissions and limitations under the License. +*/ + +// TIG's UI uses the pattern `tig_challenges::` to automatically detect your algorithm's challenge +use anyhow::{anyhow, Result}; +use tig_challenges::knapsack::{Challenge, Solution}; + +#[derive(Clone, PartialEq)] +struct Node { + level: usize, + profit: usize, + weight: usize, + bound: f64, + items: Vec, +} + +impl Node { + fn new(level: usize, profit: usize, weight: usize, bound: f64, items: Vec) -> Self { + Self { level, profit, weight, bound, items } + } +} + +pub fn solve_challenge(challenge: &Challenge) -> Result> { + let maximum_weight_capacity = challenge.max_weight as usize; + let minimum_value_required = challenge.min_value as usize; + let number_of_items = challenge.difficulty.num_items; + + let item_weights: Vec = challenge.weights.iter().map(|&weight| weight as usize).collect(); + let item_values: Vec = challenge.values.iter().map(|&value| value as usize).collect(); + + let mut items_sorted_by_value_density: Vec<(usize, f64)> = (0..number_of_items) + .map(|item_index| (item_index, item_values[item_index] as f64 / item_weights[item_index] as f64)) + .collect(); + items_sorted_by_value_density.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + + fn calculate_bound(node: &Node, maximum_weight_capacity: usize, items_sorted_by_value_density: &[(usize, f64)], item_weights: &[usize], item_values: &[usize]) -> f64 { + if node.weight >= maximum_weight_capacity { + return 0.0; + } + + let mut bound = node.profit as f64; + let mut total_weight = node.weight; + let mut j = node.level; + + while j < items_sorted_by_value_density.len() && total_weight + item_weights[items_sorted_by_value_density[j].0] <= maximum_weight_capacity { + total_weight += item_weights[items_sorted_by_value_density[j].0]; + bound += item_values[items_sorted_by_value_density[j].0] as f64; + j += 1; + } + + if j < items_sorted_by_value_density.len() { + bound += (maximum_weight_capacity - total_weight) as f64 * items_sorted_by_value_density[j].1; + } + + bound + } + + let mut max_profit = 0; + let mut best_items = Vec::new(); + let mut nodes = vec![Node::new(0, 0, 0, 0.0, Vec::new())]; + nodes[0].bound = calculate_bound(&nodes[0], maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + while let Some(node) = nodes.pop() { + if node.bound > max_profit as f64 && node.level < number_of_items { + let next_level = node.level + 1; + + // Explore the node including the next item + let next_item_index = items_sorted_by_value_density[node.level].0; + let next_weight = node.weight + item_weights[next_item_index]; + let next_profit = node.profit + item_values[next_item_index]; + + let mut include_items = node.items.clone(); + include_items.push(next_item_index); + + if next_weight <= maximum_weight_capacity && next_profit > max_profit { + max_profit = next_profit; + best_items = include_items.clone(); + } + + let mut include_node = Node::new(next_level, next_profit, next_weight, 0.0, include_items); + include_node.bound = calculate_bound(&include_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if include_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&include_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, include_node); + } + + // Explore the node excluding the next item + let mut exclude_node = Node::new(next_level, node.profit, node.weight, 0.0, node.items.clone()); + exclude_node.bound = calculate_bound(&exclude_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if exclude_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&exclude_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, exclude_node); + } + } + } + + if max_profit >= minimum_value_required { + Ok(Some(Solution { items: best_items })) + } else { + Ok(None) + } +} + +// Important! Do not include any tests in this file, it will result in your submission being rejected + +#[cfg(feature = "cuda")] +mod gpu_optimisation { + use super::*; + use cudarc::driver::*; + use std::{collections::HashMap, sync::Arc}; + use tig_challenges::CudaKernel; + + // set KERNEL to None if algorithm only has a CPU implementation + pub const KERNEL: Option = None; + + // Important! your GPU and CPU version of the algorithm should return the same result + pub fn cuda_solve_challenge( + challenge: &Challenge, + dev: &Arc, + mut funcs: HashMap<&'static str, CudaFunction>, + ) -> anyhow::Result> { + solve_challenge(challenge) + } +} +#[cfg(feature = "cuda")] +pub use gpu_optimisation::{cuda_solve_challenge, KERNEL}; diff --git a/tig-algorithms/src/knapsack/knapsplorify/mod.rs b/tig-algorithms/src/knapsack/knapsplorify/mod.rs new file mode 100644 index 00000000..fcec9672 --- /dev/null +++ b/tig-algorithms/src/knapsack/knapsplorify/mod.rs @@ -0,0 +1,4 @@ +mod benchmarker_outbound; +pub use benchmarker_outbound::solve_challenge; +#[cfg(feature = "cuda")] +pub use benchmarker_outbound::{cuda_solve_challenge, KERNEL}; \ No newline at end of file diff --git a/tig-algorithms/src/knapsack/knapsplorify/open_data.rs b/tig-algorithms/src/knapsack/knapsplorify/open_data.rs new file mode 100644 index 00000000..500dbc14 --- /dev/null +++ b/tig-algorithms/src/knapsack/knapsplorify/open_data.rs @@ -0,0 +1,140 @@ +/*! +Copyright 2014 stanlocht + +Licensed under the TIG Open Data License v1.0 or (at your option) any later version +(the "License"); you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses + +Unless required by applicable law or agreed to in writing, software distributed +under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied. See the License for the specific +language governing permissions and limitations under the License. +*/ + +// TIG's UI uses the pattern `tig_challenges::` to automatically detect your algorithm's challenge +use anyhow::{anyhow, Result}; +use tig_challenges::knapsack::{Challenge, Solution}; + +#[derive(Clone, PartialEq)] +struct Node { + level: usize, + profit: usize, + weight: usize, + bound: f64, + items: Vec, +} + +impl Node { + fn new(level: usize, profit: usize, weight: usize, bound: f64, items: Vec) -> Self { + Self { level, profit, weight, bound, items } + } +} + +pub fn solve_challenge(challenge: &Challenge) -> Result> { + let maximum_weight_capacity = challenge.max_weight as usize; + let minimum_value_required = challenge.min_value as usize; + let number_of_items = challenge.difficulty.num_items; + + let item_weights: Vec = challenge.weights.iter().map(|&weight| weight as usize).collect(); + let item_values: Vec = challenge.values.iter().map(|&value| value as usize).collect(); + + let mut items_sorted_by_value_density: Vec<(usize, f64)> = (0..number_of_items) + .map(|item_index| (item_index, item_values[item_index] as f64 / item_weights[item_index] as f64)) + .collect(); + items_sorted_by_value_density.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + + fn calculate_bound(node: &Node, maximum_weight_capacity: usize, items_sorted_by_value_density: &[(usize, f64)], item_weights: &[usize], item_values: &[usize]) -> f64 { + if node.weight >= maximum_weight_capacity { + return 0.0; + } + + let mut bound = node.profit as f64; + let mut total_weight = node.weight; + let mut j = node.level; + + while j < items_sorted_by_value_density.len() && total_weight + item_weights[items_sorted_by_value_density[j].0] <= maximum_weight_capacity { + total_weight += item_weights[items_sorted_by_value_density[j].0]; + bound += item_values[items_sorted_by_value_density[j].0] as f64; + j += 1; + } + + if j < items_sorted_by_value_density.len() { + bound += (maximum_weight_capacity - total_weight) as f64 * items_sorted_by_value_density[j].1; + } + + bound + } + + let mut max_profit = 0; + let mut best_items = Vec::new(); + let mut nodes = vec![Node::new(0, 0, 0, 0.0, Vec::new())]; + nodes[0].bound = calculate_bound(&nodes[0], maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + while let Some(node) = nodes.pop() { + if node.bound > max_profit as f64 && node.level < number_of_items { + let next_level = node.level + 1; + + // Explore the node including the next item + let next_item_index = items_sorted_by_value_density[node.level].0; + let next_weight = node.weight + item_weights[next_item_index]; + let next_profit = node.profit + item_values[next_item_index]; + + let mut include_items = node.items.clone(); + include_items.push(next_item_index); + + if next_weight <= maximum_weight_capacity && next_profit > max_profit { + max_profit = next_profit; + best_items = include_items.clone(); + } + + let mut include_node = Node::new(next_level, next_profit, next_weight, 0.0, include_items); + include_node.bound = calculate_bound(&include_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if include_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&include_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, include_node); + } + + // Explore the node excluding the next item + let mut exclude_node = Node::new(next_level, node.profit, node.weight, 0.0, node.items.clone()); + exclude_node.bound = calculate_bound(&exclude_node, maximum_weight_capacity, &items_sorted_by_value_density, &item_weights, &item_values); + + if exclude_node.bound > max_profit as f64 { + let pos = nodes.binary_search_by(|n| n.bound.partial_cmp(&exclude_node.bound).unwrap()).unwrap_or_else(|e| e); + nodes.insert(pos, exclude_node); + } + } + } + + if max_profit >= minimum_value_required { + Ok(Some(Solution { items: best_items })) + } else { + Ok(None) + } +} + +// Important! Do not include any tests in this file, it will result in your submission being rejected + +#[cfg(feature = "cuda")] +mod gpu_optimisation { + use super::*; + use cudarc::driver::*; + use std::{collections::HashMap, sync::Arc}; + use tig_challenges::CudaKernel; + + // set KERNEL to None if algorithm only has a CPU implementation + pub const KERNEL: Option = None; + + // Important! your GPU and CPU version of the algorithm should return the same result + pub fn cuda_solve_challenge( + challenge: &Challenge, + dev: &Arc, + mut funcs: HashMap<&'static str, CudaFunction>, + ) -> anyhow::Result> { + solve_challenge(challenge) + } +} +#[cfg(feature = "cuda")] +pub use gpu_optimisation::{cuda_solve_challenge, KERNEL}; diff --git a/tig-algorithms/src/knapsack/mod.rs b/tig-algorithms/src/knapsack/mod.rs index 33ddf59d..6e26c95a 100644 --- a/tig-algorithms/src/knapsack/mod.rs +++ b/tig-algorithms/src/knapsack/mod.rs @@ -16,7 +16,8 @@ // c003_a009 -// c003_a010 +pub mod knapsplorify; +pub use knapsplorify as c003_a010; // c003_a011 diff --git a/tig-algorithms/src/knapsack/template.rs b/tig-algorithms/src/knapsack/template.rs index 6386cbf8..dab73844 100644 --- a/tig-algorithms/src/knapsack/template.rs +++ b/tig-algorithms/src/knapsack/template.rs @@ -1,11 +1,7 @@ /*! -Copyright [year copyright work created] [name of copyright owner] +Copyright [yyyy] [name of copyright owner] -Identity of Submitter [name of person or entity that submits the Work to TIG] - -UAI [UAI (if applicable)] - -Licensed under the TIG Inbound Game License v2.0 or (at your option) any later +Licensed under the TIG Inbound Game License v1.0 or (at your option) any later version (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at @@ -17,24 +13,6 @@ CONDITIONS OF ANY KIND, either express or implied. See the License for the speci language governing permissions and limitations under the License. */ -// REMOVE BELOW SECTION IF UNUSED -/* -REFERENCES AND ACKNOWLEDGMENTS - -This implementation is based on or inspired by existing work. Citations and -acknowledgments below: - -1. Academic Papers: - - [Author(s), "Paper Title", DOI (if available)] - -2. Code References: - - [Author(s), URL] - -3. Other: - - [Author(s), Details] - -*/ - // TIG's UI uses the pattern `tig_challenges::` to automatically detect your algorithm's challenge use anyhow::{anyhow, Result}; use tig_challenges::knapsack::{Challenge, Solution}; diff --git a/tig-algorithms/wasm/knapsack/knapsplorify.wasm b/tig-algorithms/wasm/knapsack/knapsplorify.wasm new file mode 100644 index 0000000000000000000000000000000000000000..5b23df3ece2f82190f8afff60e03e31c85213fcb GIT binary patch literal 156848 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 literal 0 HcmV?d00001