Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/functions.inc | <?php
/*
* Datei: functions.inc
* reason: Determination of the country codes for the
* Shipping data form.
*/
function getStateCode()
{
$stateCode = array( 1 =>
"BE",
"DA",
"DE",
"FO",
"FI",
"FR",
"EL",
"GA",
"IT",
"LI",
"LU",
"MO",
"NL",
"AT",
"PL",
"SV",
"CH",
"ES",
"TR" );
return $stateCode;
}
function getStateName()
{
$stateName = array( 1 =>
"Belgium",
"Danemark",
"Germany",
"Faroer Isles",
"Finnland",
"France",
"Greece",
"ireland",
"Italy",
"Liechtenstein",
"Luxenbourg",
"Monaco",
"Netherlands",
"Austria",
"Poland",
"Sweden",
"Switzerland",
"Spain",
"Turkey" );
return $stateName;
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/fields_summary.inc | <?php
/*
* file: fields_summary.inc
* reason: Generates the data required to display a summary
* of the arrays required for the order.
*/
$page = array(
"title" => "The DIY Store - Order",
"top" => "The DIY Store - Order",
"top2" => "Order summary",
"bottom" => "If you have any questions or problems, please contact [email protected]"
);
$table_headers = array(
"Pos.","Kat.Nr.","Bezeichnung","Menge","Preis","Gesamt"
);
$order_number = $_SESSION['bestell_nr'];
$shipping_rate = .25;
$table_name = $order_number;
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/fields_product_page.inc | <?php
/*
* file: fields_product_page.inc
* reason: Defines the variables and creates the variables to be displayed
* the product page of the catalog required Arrays
*/
$page = array(
"title" => "The DIY Store - Catalog",
"top" => "The DIY Store - Catalog",
"bottom" => "If you have any questions or problems, please contact [email protected]"
);
$table_heads = array(
"katalog_nr" => "Art.Nr.",
"name" => "Name",
"pr_beschr" => "Description",
"preis" => "Price",
"menge" => "Quantity"
);
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/summary_page.inc | <?php
/*
* file: summary_page.inc
* reason: Defines an HTML page that displays a summary
* of the order.
*/
echo "<html>
<head><title>{$page['title']}</title></head>\n
<body>\n";
echo "<h2 style='text-align:center'>{$page['top']}</h2>";
echo "<p style='position:absolute;margin-top:.25in;
font-weight:bold'>Address:</p>";
echo "<p style='position:absolute;margin-top:.25in;
margin-left:.75in'>$ship_name<br>";
echo "$ship_street<br>
$ship_zip $ship_city $ship_state<br>
$phone<br>
$email<br>";
echo "<div style='margin-top:1.5in'>";
echo "<p style='font-weight:bold'>
Order number: $table_name\n";
echo "<table border='0' style='width:100%'>\n";
echo "<form action='$_SERVER[PHP_SELF]' method='POST'>";
echo "<tr>";
foreach($table_headers as $header)
{
echo "<th>$header</th>\n";
}
echo "</tr><tr><hr></tr>";
for($i=1;$i<=sizeof($items);$i++)
{
echo "<tr>";
echo "<td width='10%' align='center'>$i</td>";
echo "<td width='10%' align='center'>{$items[$i]['katalog_nr']}</td>";
echo "<td align='center'>{$items[$i]['name']}</td>";
echo "<td align='center'>{$items[$i]['menge']}</td>";
$f_price = number_format($items[$i]['preis'],2);
echo "<td align='right' width='12%'>$f_price Euro</td>\n";
$total = $items[$i]['quantity'] * $items[$i]['price'];
$f_total = number_format($total,2);
echo "<td align='right' width='12%'>$f_total Euro</td>\n";
echo "</tr>";
@$order_subtotal = $order_subtotal + $total;
}
$f_order_subtotal = number_format($order_subtotal,2);
if($ship_state == DE) # Steuer nur fuer Deutschland
{
$taxrate = 0.0700;
}
else
{
$taxrate = 0.00;
}
$sales_tax = $order_subtotal * $taxrate;
$f_sales_tax = number_format($sales_tax,2);
$shipping = $shipping_rate * sizeof($items);
$f_shipping = number_format($shipping,2);
$order_total = $order_subtotal + $sales_tax + $shipping;
$f_order_total = number_format($order_total,2);
echo "<tr><td colspan='6'><hr></td></tr>\n";
echo "<tr><td colspan='5' style='text-align:right;font-weight:bold'>Zwischensumme</td></tr><td style='text-align:right;line-height:200%'>$f_order_subtotal Euro</td></tr>\n";
echo "<tr><td colspan='5' style='text-align:right;font-weight:bold;>MwSt</td><td style='text-align:right;line-height:75%'>$f_sales_tax Euro</td></tr>\n";
echo "<tr><td colspan='5' style='text-align:right;font-weight:bold;>Versandkosten</td><td style='text-align:right;line-height:75%'>$f_shipping</td></tr>\n";
echo "<tr><td colspan='6'><hr></td></tr>\n";
echo "<tr><td colspan='5' style='text-align:right;font-weight:bold;>Gesamtsumme</td><td style='text-align:right;line-height:300%'>$f_order_total</td></tr>\n";
echo "<tr><td colspan='2' style='text-align:left;'><input type='submit' value='Einkauf fortsetzen'></td>\n";
echo "<tr><td colspan='1' style='text-align:left;'><input type='submit' name='Ship' value='Versanddaten bearbeiten'></td>\n";
echo "<tr><td colspan='1' style='text-align:left;'><input type='submit' name='Final' value='Bestellung abbrechen'></td>\n";
echo "<tr><td colspan='2' style='text-align:right;'><input type='submit' name='Final' value='Bestellung aufgeben'></td>\n";
echo "</tr></table></form>\n";
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/fields_cart-oo.inc | <?php
/*
* file: fields_cart-oo.inc
* reason: Contains the information required to display the shopping cart relevant data
*/
$page = array(
"title" => "The DIY Store - SHopping cart",
"top" => "The DIY Store",
"top2" => "Shopping Cart",
"bottom" => "If you have any questions or problems, please contact [email protected]"
);
$table_headers = array(
"Pos.","Kat.Nr.","Bezeichnung","Menge",
"Preis","Gesamt"
);
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/shopping_product_page-oo.inc | <?php
/*
* file: shopping_product_page-oo.inc
* reason: Displays the products from the catalog for a
* selected product group.
*/
include_once("fields_product_page.inc");
?>
<html>
<head>
<title>
<?php echo $page['title'] ?>
</title>
</head>
<body>
<?php
echo "<form action='$_SERVER[PHP_SELF]' method='POST'>\n
<p style='text-align:right'>\n
<input type='submit' name='Cart' value='Warenkorb anzeigen'>\n
</form>\n";
echo "<div style='margin-left:.1in;margin-right:.1in'>
<h1 align='center'>{$page['top']}</h1>
<p style='font-size:150%'><b>{$_POST['interest']}</b>\n";
echo "<p align='right'>$n_products Produkt(e) gefunden";
echo "<table border='0' cellpadding='5' width='100%'>";
echo "<tr>";
foreach($table_heads as $heading)
{
echo "<th>$heading</th>";
}
echo "</tr>";
echo "<form action='$_SERVER[PHP_SELF]' method='POST'>\n";
for ($i=$n_start;$i<=$n_end;$i++)
{
echo "<tr>";
echo "<td align='center' width='10%'>{$all[$i]->katalog_nr}</td>\n";
echo "<td align='center'>{$all[$i]->name}</td>\n";
echo "<td align='center'>{$all[$i]->pr_beschr}</td>\n";
echo "<td align='right' width='12%'>{$all[$i]->preis} Euro</td>\n";
echo "<td align='center' width='12%'><input type='text' name='item{$all[$i]->katalog_nr}' value='0' size='4'></td>\n";
echo "</tr>";
}
echo "<input type='hidden' name='n_end' value='$n_end'>";
echo "<input type='hidden' name='interest' value='$_POST[interest]'>";
echo "<tr>
<td colspan='2'>
<input type='submit' value='Other category'></td>\n";
echo "<td colspan='2'>
<input type='submit' name='Cart' value='Add to shopping cart'></td>\n";
echo "<td colspan='2' align='right'>\n";
if($n_end > $n_per_page)
{
echo "<input type='submit' name='Products' value='Previous'>\n";
}
if($n_end < $n_products)
{
echo "<input type='submit' name='Products' value='Next $n_per_page'>\n";
}
echo "</td></form></tr></table>\n";
echo "<p style='align:center;'><font size='-1'>{$page['bottom']}</font></p>\n";
?>
</div>
</body>
</html>
|
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/vars.inc | <?php
$host = "localhost";
$user = "root";
$passwd = "";
$database = "baumarkt";
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/ShoppingCart.php | <?php
/**
* file: ShoppingCart.php
* reason: Creates a shopping cart (structure with articles)
*/
class ShoppingCart
{
private $items = array();
private $message;
private $n_items=0;
function __construct()
{
if(isset($_SESSION['items']))
{
$this->items=$_SESSION['items'];
$this->n_items=sizeof($this->items);
}
$this->message="Shopping cart contains
{$this->n_items} item.";
}
function addItem(Item $item)
{
$this->items[]=$item;
$_SESSION['items']=$this->items;
$this->n_items++;
$this->message="Shopping card contains {$this->n_items} items.";
}
function getAllItems()
{
return $this->items;
}
function getMessage()
{
return $this->message;
}
function displayCart($file_fields,$file_page)
{
if(is_string($file_fields) || is_string($file_page))
{
include($file_fields);
include($file_page);
}
else
{
throw new Exception("Two filenames needed.");
}
}
function updateCart($new_array)
{
if(is_array($new_array))
{
foreach($new_array as $field => $value)
{
if(preg_match("/item/",$field) && $value>0)
{
$cat_no = substr($field,4);
$items_new[] = new Item($cat_no,$value);
}
}
$this->items = @$items_new;
$_SESSION["items"]=$this->items;
$this->n_items=sizeof($this->items);
$this->message="Shopping cart contains {$this->n_items} items.";
}
else
{
throw new Exception("Parameter is not an Array");
}
}
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/include_db.php | <?php
$dbHost="localhost";
$dbName="baumarkt";
$dbCharset="utf8";
$dbUser="root";
$dbPw="";
try
{
$db=new PDO(
"mysql:host=$dbHost;dbname=$dbName;charset=$dbCharset",
$dbUser,
$dbPw
);
}
catch(PDOException $e)
{
exit("No connection to database");
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/WebForm.php | <?php
/**
* file: WebForm.php
* reason: Collects, saves and processes the data
* in an HTML form.
*/
class WebForm
{
const FORM = "single_form.inc";
// private $form; // filename
const FIELDS = "fields_ship_info.inc";
// private $fields; // filename
private $data; // Array
private $not_required; // Array
function __construct($form,$fields,$data=NULL)
{
if(is_string($form) and is_string($fields))
{
echo "<pre>";
#var_dump($form);
#var_dump($fields);
echo "</pre>";
$this->form=$form;
$this->fields=$fields;
}
else
{
throw new Exception("The first 2 parameters must be filename.");
}
if($data==NULL OR is_array($data))
{
$this->data=$data;
}
else
{
throw new Exception("The first 2 parameters must be filename.");
}
}
function setFieldsNotRequired($not_required)
{
if( !is_array($not_required))
{
throw new Exception("Fields must be passed in an array.");
}
else
{
$this->not_required = $not_required;
}
}
function displayForm()
{
#echo "<pre>";
#var_dump($this->data);
#var_dump($this->fields);
#var_dump($this->form);
@extract($this->data);
include($this->fields);
#var_dump($page);
include($this->form);
echo "</pre>";
}
function getAllFields()
{
return $this->data;
}
function checkForBlanks()
{
if(sizeof($this->data) < 1)
{
throw new Exception("No formular data.");
}
foreach($this->data as $key => $value)
{
if($value == "")
{
$match = "no";
if(is_array($this->not_required))
{
foreach($this->not_required as $field)
{
if($field == $key)
{
$match == "yes";
}
}
}
if($match == "no")
{
$blanks[] = $key;
}
}
}
if(isset($blanks))
{
return $blanks;
}
else
{
return TRUE;
}
}
function verifyData()
{
if(sizeof($this->data)<1)
{
throw new Exception("Keine Formulardaten");
}
foreach($this->data as $key => $value)
{
if(!empty($value))
{
if(preg_match("/name/",$key) and !preg_match("/user/",$key))
{
$result = $this->checkName($value);
if(is_string($result))
{
$errors[$key] = $result;
}
}
if(preg_match("/addr/",$key) or preg_match("/street/",$key) or preg_match("/city/",$key))
{
$result = $this->checkAddress( $value );
if(is_string($result))
{
$errors[$key] = $result;
}
}
if(preg_match("/email/",$key))
{
$result = $this->checkEmail($value);
if(is_string($result))
{
$errors[$key] = $result;
}
}
if(preg_match("/phone/",$key) or preg_match("/fax/",$key))
{
$result = $this->checkPhone($value);
if(is_string($result))
{
$errors[$key] = $result;
}
}
if(preg_match("/zip/",$key))
{
$result = $this->checkZip($value);
if(is_string($result))
{
$errors[$key] = $result;
}
}
}
}
if(isset($errors))
{
return $errors;
}
else
{
return TRUE;
}
}
function trimData()
{
foreach($this->data as $key => $value)
{
$data[$key] = trim($value);
}
$this->data = $data;
}
function stripTagsFromData()
{
foreach($this->data as $key => $value)
{
$data[$key] = strip_tags($value);
}
$this->data = $data;
}
function checkName($field)
{
if(!preg_match("/^[A-Za-z' -]{1,50}$/",$field))
{
return "$field ist kein gültiger Name. Versuchen Sie es erneut.";
}
else
{
return TRUE;
}
}
function checkAddress($field)
{
if(!preg_match("/^[A-Za-z0-9.,' -]{1,50}$/",$field))
{
return "$field ist keine gültige Adresse. Versuchen Sie es erneut.";
}
else
{
return TRUE;
}
}
function checkZip($field)
{
if(!preg_match("/^[0-9]{5}{\-[0-9]{4}}?$/",$field))
{
return "$field ist keine gültige Postleitzahl. Versuchen Sie es erneut.";
}
else
{
return TRUE;
}
}
function checkPhone($field)
{
if(!preg_match("/^[0-9]) (Xx -]{7,20}$/",$field))
{
return "$field ist keine gültige Tel. Nr. Versuchen Sie es erneut.";
}
else
{
return TRUE;
}
}
function checkEmail($field)
{
if(!preg_match("/^.+@.+\\..+$/",field))
{
return "$field ist keine gültige E-Mail-Adresse. Versuchen Sie es erneut.";
}
else
{
return TRUE;
}
}
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/WebPage.php | <?php
/**
* Datei: WebPage.php
* Zweck: Klasse speichert die zur Anzeige der Webseite
* erforderlichen Daten.
*/
class WebPage
{
private $filename;
private $data;
function __construct($filename,$data=NULL)
{
if(is_string($filename))
{
$this->filename = $filename;
}
else
{
throw new Exception("filename has to be string.");
}
if($data == NULL or is_array($data))
{
$this->data = $data;
}
else
{
throw new Exception("Data must be transferred to an array.");
}
}
function displayPage()
{
include("fields_summary-oo.inc");
@extract($this->data);
include($this->filename);
}
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/Item.php | <?php
/**
* file: Item.php
* reason: Single element of the order
*/
class Item
{
private $catalog_number;
private $quantity;
private $name;
private $price;
function __construct($cat_no,$quantity)
{
if(is_string($cat_no) && is_numeric($quantity))
{
$this->menge = $quantity;
$this->katalog_nr = $cat_no;
$cat = new Catalog("vars.inc");
$cat->selectCatalog("baumarkt");
$this->name = $cat->getName($cat_no);
$this->preis = $cat->getPrice($cat_no);
}
else
{
throw new Exception("Parameter no valid catalog number/quantity");
}
}
function getCatalogNumber()
{
return $this->katalog_nr;
}
function getQuantity()
{
return $this->menge;
}
function getPrice()
{
return $this->preis;
}
function getName()
{
return $this->name;
}
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/fields_index_page.inc | <?php
/**
* file: fields_index_page.inc
* reason: Creates the product categories used to display the
* catalog required Arrays.
*/
$page = array(
"title" => "The DIY Store - Catalog",
"top" => "The DIY Store - Catalog",
"top2" => "Select one of the following categories",
"bottom" => "If you have any questions or problems, please contact [email protected]"
);
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/connect_to_db.inc | <?php
/**
* file: connect_to_db.inc
* reason: Establish a connection to a MySQL database. Name of a
* file with the database variables is passed to the function.
*/
function connect_to_db($filename)
{
include($filename);
$connection = mysqli_connect($host,$user,$passwd) or die ('No connection to server');
$db = mysqli_select_db($connection,$database) or die ("Databse not available.");
return $connection;
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/Order.php | <?php
/**
* file: Order.php
* reason: Contains orders
*/
class Order
{
private $order_number;
private $order_info;
private $order_items=array();
private $cxn;
private $table;
function __construct(mysqli $cxn,$table)
{
$this->cxn=$cxn;
if(is_string($table))
{
$this->table = $table;
}
else
{
throw new Exception("$table is not a valid table name.");
}
}
function createOrder()
{
$today = date("Y-m-d");
$sql = "INSERT INTO $this->table (bestell_date) VALUES ('$today')";
if($result = $this->cxn->query($sql))
{
$this->bestell_nr = $this->cxn->insert_id;
$_SESSION['bestell_nr'] = $this->bestell_nr;
}
else
{
throw new Exception("Database not available. Try again later");
}
}
function getOrderNumber()
{
return $this->bestell_nr;
}
function addCart(ShoppingCart $cart)
{
foreach($cart->getAllItems() as $n=>$item)
{
$cat_no=$item->getCatalogNumber();
$quantity=$item->getQuantity();
$price=$item->getPrice();
$sql = "INSERT INTO bestell_nr (bestell_nr,katalog_nr,menge,pos_nr,preis) VALUES ($this->katalog_nr,$cat_no,$quantity,($n+1),$price)";
$result = $this->cxn->query($sql);
}
}
function selectOrder($order_number)
{
if(is_int($order_number))
{
$this->bestell_nr = $order_number;
}
else
{
throw new Exception("$order_number not Integer.");
}
}
function getOrderInfo()
{
$sql = "SELECT * FROM $this->table WHERE bestell_nr = '$this->bestell_nr'";
if($result = $this->cxn->query($sql))
{
return $result->fetch_assoc();
}
else
{
throw new Exception("Database not available. Try again later.");
}
}
function getItemInfo()
{
$sql = "SELECT pos_nr,katalog_nr,menge,preis FROM bestell_auftrag WHERE bestell_nr = '$this->bestell_nr'";
if($result = $this->cxn->query($sql))
{
$n=1;
while($row=$result->fetch_assoc())
{
foreach($row as $field => $value)
{
$item[$n][$field] = $value;
}
$cat = new Catalog("vars.inc");
$cat->selectCatalog("baumarkt");
$item[$n]['name'] = $cat->getName($item[$n]['katalog_nr']);
$n++;
}
return $item;
}
else
{
throw new Exception("Database not available. Try again later.");
}
}
function updateOrderInfo($data)
{
if(!is_array($data))
{
throw new Exception("Data not available as an array!");
exit();
}
$sql = "UPDATE $this->table SET ";
foreach($data as $field => $value)
{
if(preg_match("ship",$field) || $field == "telefon" || $field == "email")
{
$data_array[] = "$field='$value'";
}
}
$sql .= implode($data_array,',');
$sql .= "WHERE bestell_nr = '$this->bestell_nr'";
if(!$result = $this->cxn->query($sql))
{
throw new Exception("Database not available. Try again later.");
}
return true;
}
function displayOrderInfo($field_info,$field_page)
{
$data = $this->getOrderInfo();
$items = $this->getItemInfo();
extract($data);
if(is_string($field_info) and is_string($field_page))
{
include($field_info);
include($field_page);
}
else
{
throw new Exception("Parameter are no filenames.");
}
}
}
?> |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/Orders-oo.php | <?php
/**
* file: Orders-oo.php
* reason: Executes all functions of the online shopping
* application. The name of the submit button is checked to determine * which part of the program is to be executed,
* which part of the program is to be executed.
*/
require_once("ShoppingCart.php");
require_once("Catalog.php");
require_once("Item.php");
require_once("WebForm.php");
require_once("WebPage.php");
require_once("Order.php");
require_once("Database.php");
include_once("functions.inc");
session_start();
if(isset($_POST['Products']) && isset($_POST['interest']))
{
try
{
$catalog=new Catalog('vars.inc');
$catalog->selectCatalog('baumarkt');
$catalog->displayAllofType($_POST['interest'],2);
}
catch(Exception $e)
{
echo $e->getMessage();
exit();
}
}
elseif(isset($_POST['Cart']))
{
$cart = new ShoppingCart();
if($_POST['Cart'] == "Warenkorb aktualisieren")
{
try
{
$cart->updateCart($_POST);
}
catch(Exception $e)
{
echo $e->getMessage();
exit();
}
}
elseif($_POST['Cart'] == "In den Warenkorb")
{
foreach($_POST as $field => $value)
{
if(preg_match("/item/",$field) && $value > 0)
{
try
{
$cat_no = substr($field,4);
$item = new Item($cat_no,$value);
$cart->addItem($item);
}
catch(Exception $e)
{
echo $e->getMessage();
exit();
}
}
}
}
try
{
$cart->displayCart("fields_cart-oo.inc","table_page-oo.inc");
}
catch (Exception $e)
{
echo $e->getMessage;
exit();
}
}
elseif(isset($_POST['Ship']))
{
try
{
$db = new Database("vars.inc");
$db->useDatabase("baumarkt");
$order = new Order($db->getConnection(),"bestellung");
if(isset($_SESSION['bestell_nr']))
{
$order->selectOrder($_SESSION['bestell_nr']);
}
else
{
$order->createOrder();
}
$ord = $order->getOrderNumber();
$info = $order->getOrderInfo();
$form = new WebForm("single_form.inc","fields_ship_info.inc",$info);
$form->displayForm();
}
catch (Exception $e)
{
echo $e->getMessage();
exit();
}
}
elseif(isset($_POST['Summary']))
{
try
{
$form = new WebForm("single_form.inc","fields_ship_info.inc",$_POST);
$blanks = $form->checkForBlanks();
}
catch (Exception $e)
{
echo $e->getMessage();
}
if(is_array($blanks))
{
$GLOBALS['message'] = "Die foglenden Felder sind
leer. Bitte geben Sie die
erforderlichen Daten ein: ";
foreach($blanks as $value)
{
$GLOBALS['message'].="$value, ";
}
$form->trimData();
$form->stripTagsFromData();
try
{
$errors = $form->verifyData();
}
catch(Exception $e)
{
echo $e->getMessage();
}
if(is_array($errors))
{
$GLOBAL['message']="";
foreach($errors as $value)
{
$GLOBALS['message'].="$value<br> ";
}
$form->displayForm();
exit();
}
try
{
$db = new Database("vars.inc");
$db->useDatabase("baumarkt");
$order = new Order($db->getConnection(),"bestellung");
$order->selectOrder($_SESSION['bestell_nr']);
// Versanddaten in DB aufnehmen.
$order->updateOrderInfo($_POST);
// Elemente in DB aufnehmen
$cart = new ShoppingCart();
$order->addCart($cart);
// Auftragszusammenfassung anzeigen
$order->displayOrderSummary("fields_summary-oo.inc","summary_page.inc");
}
catch(Exception $e)
{
echo $e->getMessage();
}
}
elseif(isset($_POST['Final']))
{
if($_POST['Final'] == "Bestellung aufgeben")
{
$order->setSubmitted();
$order->sendToShipping();
$order->sendEMailtoCustomer();
$confirm = new WebPage("confirm_page.inc",$data);
$confirmpage->displayPage();
}
else
{
$order->cancel();
$unapp = new WebPage("not_accepted_page.inc",$data);
$unapp->displayPage();
unset($_SESSION['bestell_nr']);
unset($_SESSION);
session_destroy();
}
}
else
{
$order->cancel();
$cancel = new WebPage("not_accepted_page.inc",$data);
$cancel->displayPage();
unset($_SESSION['bestell_nr']);
unset($_SESSION );
session_destroy();
}
}
else
{
$catalog = new Catalog("vars.inc");
$catalog->selectCatalog("baumarkt");
$catalog->displayCategories();
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src | repos/exploratory-tech-studio/tech-studio-projects/web-applications/diy-store/src/database/baumarkt.sql | -- phpMyAdmin SQL Dump
-- version 5.1.1
-- https://www.phpmyadmin.net/
--
-- Host: 127.0.0.1
-- Erstellungszeit: 25. Sep 2021 um 20:03
-- Server-Version: 10.4.21-MariaDB
-- PHP-Version: 7.3.30
SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
START TRANSACTION;
SET time_zone = "+00:00";
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;
--
-- Datenbank: `baumarkt`
--
-- --------------------------------------------------------
--
-- Tabellenstruktur für Tabelle `benutzer`
--
CREATE TABLE `benutzer` (
`userID` int(11) NOT NULL,
`userName` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
`userEmail` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
`userRole` int(11) NOT NULL DEFAULT 1,
`userPassword` varchar(255) COLLATE utf8_unicode_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
--
-- Daten für Tabelle `benutzer`
--
INSERT INTO `benutzer` (`userID`, `userName`, `userEmail`, `userRole`, `userPassword`) VALUES
(1, 'Alfred', '[email protected]', 2, 'aaa'),
(2, 'Berta', '[email protected]', 2, ''),
(3, 'Chris', '[email protected]', 1, ''),
(4, 'Dora', '[email protected]', 1, ''),
(5, 'Andi', '[email protected]', 1, '$2y$12$7lSGjrA9gUc/NrFJYroBo.AKvKrviO2MqiYE6N/PVw.EmwsbhTW3m'),
(6, 'Test', '[email protected]', 1, '$2y$12$FvMud031IAoBPpZMsFX6JuHiul7z8BhxFVL8iFT5Lo5saomieS8zu');
-- --------------------------------------------------------
--
-- Tabellenstruktur für Tabelle `bestellung`
--
CREATE TABLE `bestellung` (
`bestell_nr` int(6) NOT NULL,
`bestell_date` date DEFAULT NULL,
`versandkosten` decimal(9,2) NOT NULL,
`um_steuer` decimal(9,2) NOT NULL,
`status_auftrag` enum('ja','nein') COLLATE latin1_german1_ci NOT NULL,
`vers_name` varchar(50) COLLATE latin1_german1_ci NOT NULL,
`vers_strasse` varchar(50) COLLATE latin1_german1_ci NOT NULL,
`vers_postl` char(10) COLLATE latin1_german1_ci NOT NULL,
`vers_ort` varchar(50) COLLATE latin1_german1_ci NOT NULL,
`sta` char(2) COLLATE latin1_german1_ci NOT NULL,
`email` char(50) COLLATE latin1_german1_ci NOT NULL,
`telefon` char(20) COLLATE latin1_german1_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_german1_ci;
--
-- Daten für Tabelle `bestellung`
--
INSERT INTO `bestellung` (`bestell_nr`, `bestell_date`, `versandkosten`, `um_steuer`, `status_auftrag`, `vers_name`, `vers_strasse`, `vers_postl`, `vers_ort`, `sta`, `email`, `telefon`) VALUES
(0, '2021-09-25', '0.00', '0.00', 'ja', '', '', '', '', '', '', '');
-- --------------------------------------------------------
--
-- Tabellenstruktur für Tabelle `bestell_auftrag`
--
CREATE TABLE `bestell_auftrag` (
`bestell_nr` int(6) NOT NULL,
`pos_nr` int(4) NOT NULL,
`katalog_nr` int(8) NOT NULL,
`menge` decimal(7,2) NOT NULL,
`preis` decimal(7,2) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_german1_ci;
-- --------------------------------------------------------
--
-- Tabellenstruktur für Tabelle `katalog`
--
CREATE TABLE `katalog` (
`katalog_nr` int(11) NOT NULL,
`name` varchar(50) COLLATE latin1_german1_ci NOT NULL,
`fabrikat` varchar(50) COLLATE latin1_german1_ci NOT NULL,
`best_nr` int(9) NOT NULL,
`preis` decimal(7,2) NOT NULL,
`pr_beschr` varchar(200) COLLATE latin1_german1_ci NOT NULL,
`kateins` varchar(30) COLLATE latin1_german1_ci NOT NULL,
`katzwei` varchar(30) COLLATE latin1_german1_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_german1_ci;
--
-- Daten für Tabelle `katalog`
--
INSERT INTO `katalog` (`katalog_nr`, `name`, `fabrikat`, `best_nr`, `preis`, `pr_beschr`, `kateins`, `katzwei`) VALUES
(1, 'Gartenstuhl', 'Kettler', 3455556, '209.00', 'Aufklappbarer Gartenstuhl', 'Garten', 'Gartenmoebel'),
(2, 'Gartentisch', 'MWH', 445897, '499.00', 'Stelltisch fuer den Garten', 'Garten', 'Gartenmoebel'),
(3, 'Gartenrechen', 'Maurer', 337561, '22.00', 'Multifunktions Rechen', 'Garten', 'Gartengeräte'),
(4, 'Schaufel', 'Inso', 127834, '15.00', 'HOEKEL Schaufel', 'Garten', 'Gartengeräte'),
(5, 'Duschbecken', 'Krisall', 679124, '478.89', 'Duschbecken spezial fuer Kinder', 'Sanitär', 'Badausbau'),
(6, 'Brause', 'Wellness', 765467, '78.99', 'MIELE Brause fuer Stemp', 'Sanitär', 'Badausbau'),
(7, 'Toilettenschüssel', 'Krana', 235886, '123.00', 'Keramikschuessel und goldener Rand', 'Sanitär', 'Toilettenausbau'),
(8, 'Wasserhahn', 'Miller', 349789, '56.00', 'Hahn mit Wasser aus Edelstahl', 'Sanitär', 'Toilettenausbau');
--
-- Indizes der exportierten Tabellen
--
--
-- Indizes für die Tabelle `bestellung`
--
ALTER TABLE `bestellung`
ADD PRIMARY KEY (`bestell_nr`);
--
-- Indizes für die Tabelle `bestell_auftrag`
--
ALTER TABLE `bestell_auftrag`
ADD PRIMARY KEY (`bestell_nr`);
--
-- Indizes für die Tabelle `katalog`
--
ALTER TABLE `katalog`
ADD PRIMARY KEY (`katalog_nr`);
--
-- AUTO_INCREMENT für exportierte Tabellen
--
--
-- AUTO_INCREMENT für Tabelle `katalog`
--
ALTER TABLE `katalog`
MODIFY `katalog_nr` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=9;
COMMIT;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation/java/Main.java | public class Main {
/**
* Main function to demonstrate maximum likelihood estimation.
*/
public static void main(String[] args) {
// Example: Estimate parameters using maximum likelihood estimation
double[] observedData = {1.2, 1.5, 2.0, 2.2, 2.8};
double[] estimatedParams = MaximumLikelihoodEstimation.maximumLikelihoodEstimation(observedData);
System.out.println("Estimated parameters (mean, standard deviation): " +
estimatedParams[0] + ", " + estimatedParams[1]);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation/java/MaximumLikelihoodEstimation.java | import org.apache.commons.math3.analysis.MultivariateFunction;
import org.apache.commons.math3.optim.MaxEval;
import org.apache.commons.math3.optim.SimpleValueChecker;
import org.apache.commons.math3.optim.nonlinear.scalar.GoalType;
import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateFunctionMappingAdapter;
import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateOptimizer;
import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.NelderMeadSimplex;
import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.SimplexOptimizer;
import org.apache.commons.math3.optim.PointValuePair;
public class MaximumLikelihoodEstimation {
/**
* Perform maximum likelihood estimation to estimate the parameters of the statistical model.
*
* @param data The observed data.
* @return The estimated parameters of the statistical model (mean and standard deviation).
*/
public static double[] maximumLikelihoodEstimation(double[] data) {
MultivariateFunction likelihoodFunction = new LikelihoodFunction(data);
MultivariateOptimizer optimizer = new SimplexOptimizer(new SimpleValueChecker(1e-10, 1e-30));
MultivariateFunctionMappingAdapter boundedLikelihoodFunction =
new MultivariateFunctionMappingAdapter(likelihoodFunction, new double[] {Double.NEGATIVE_INFINITY, 0},
new double[] {Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY});
PointValuePair result = optimizer.optimize(new MaxEval(1000),
new NelderMeadSimplex(2),
GoalType.MINIMIZE,
new org.apache.commons.math3.optim.InitialGuess(new double[] {0, 1}),
boundedLikelihoodFunction);
return result.getPoint();
}
static class LikelihoodFunction implements MultivariateFunction {
private final double[] data;
LikelihoodFunction(double[] data) {
this.data = data;
}
/**
* Compute the likelihood function for the given parameters and data.
*
* @param params The parameters of the statistical model (mean and standard deviation).
* @return The negative likelihood value (to be minimized).
*/
@Override
public double value(double[] params) {
double mu = params[0];
double sigma = params[1];
double likelihood = 0.0;
for (double d : data) {
likelihood += Math.log(1 / (Math.sqrt(2 * Math.PI) * sigma) *
Math.exp(-0.5 * Math.pow((d - mu) / sigma, 2)));
}
return -likelihood; // Minimize negative likelihood (equivalent to maximizing likelihood)
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation/cpp/maximumLikelihoodEstimation.h | #ifndef MAXIMUM_LIKELIHOOD_ESTIMATION_H
#define MAXIMUM_LIKELIHOOD_ESTIMATION_H
#include <vector>
#include <utility>
/**
* Compute the likelihood function for the given parameters and data.
*
* @param params The parameters of the statistical model (mean and standard deviation).
* @param data The observed data.
* @return The negative likelihood value (to be minimized).
*/
double likelihood_function(const std::pair<double, double>& params, const std::vector<double>& data);
/**
* Perform maximum likelihood estimation to estimate the parameters of the statistical model.
*
* @param data The observed data.
* @return The estimated parameters of the statistical model (mean and standard deviation).
*/
std::pair<double, double> maximum_likelihood_estimation(const std::vector<double>& data);
#endif // MAXIMUM_LIKELIHOOD_ESTIMATION_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(BubbleSort)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(BubbleSort main.cpp bubbleSort.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation/cpp/maximumLikelihoodEstimation.cpp | #include "maximum_likelihood_estimation.h"
#include <cmath>
#include <algorithm>
#include <limits>
/**
* Compute the likelihood function for the given parameters and data.
*
* @param params The parameters of the statistical model (mean and standard deviation).
* @param data The observed data.
* @return The negative likelihood value (to be minimized).
*/
double likelihood_function(const std::pair<double, double>& params, const std::vector<double>& data) {
double mu = params.first;
double sigma = params.second;
double likelihood = 0.0;
for (double d : data) {
likelihood += std::log(1 / (std::sqrt(2 * M_PI) * sigma) * std::exp(-0.5 * std::pow((d - mu) / sigma, 2)));
}
return -likelihood; // Minimize negative likelihood (equivalent to maximizing likelihood)
}
/**
* Perform maximum likelihood estimation to estimate the parameters of the statistical model.
*
* @param data The observed data.
* @return The estimated parameters of the statistical model (mean and standard deviation).
*/
std::pair<double, double> maximum_likelihood_estimation(const std::vector<double>& data) {
std::pair<double, double> initial_guess = {0.0, 1.0};
std::pair<double, double> best_params = initial_guess;
double best_likelihood = std::numeric_limits<double>::infinity();
double step = 0.1;
for (double mu = -10.0; mu <= 10.0; mu += step) {
for (double sigma = 0.1; sigma <= 10.0; sigma += step) {
std::pair<double, double> params = {mu, sigma};
double likelihood = likelihood_function(params, data);
if (likelihood < best_likelihood) {
best_likelihood = likelihood;
best_params = params;
}
}
}
return best_params;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/maximum-likelihood-estimation/cpp/main.cpp | #include <iostream>
#include <vector>
#include "maximum_likelihood_estimation.h"
/**
* Main function to demonstrate maximum likelihood estimation.
*/
int main() {
// Example: Estimate parameters using maximum likelihood estimation
std::vector<double> observed_data = {1.2, 1.5, 2.0, 2.2, 2.8};
auto estimated_params = maximum_likelihood_estimation(observed_data);
std::cout << "Estimated parameters (mean, standard deviation): " << estimated_params.first << ", " << estimated_params.second << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/monte-carlo | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/monte-carlo/java/MonteCarlo.java | import java.util.Random;
/**
* MonteCarlo.java
*
* The Monte Carlo method is a statistical technique used to estimate numerical results by random sampling.
* In this implementation, we use the Monte Carlo method to estimate the value of pi by simulating random points
* within a unit square and determining the ratio of points that fall within the unit circle.
*
* Algorithm: We generate numSamples random points uniformly distributed within the unit square [-1, 1] x [-1, 1].
* For each point, we calculate its distance from the origin and count how many points fall within the unit circle
* (i.e., have a distance <= 1 from the origin). The ratio of points inside the circle to the total number of points
* approximates the ratio of the area of the unit circle to the area of the unit square, which is π/4.
*
* Implementation: The monteCarloPi method takes the number of samples numSamples as input and iterates through the
* algorithm to estimate the value of pi using the Monte Carlo method. It returns the estimated value of pi.
*
* Example Usage: In the main method, an example usage of the monteCarloPi function is provided. We specify the
* number of samples, call the function to estimate pi, and then print the result. Increasing the number of samples
* generally leads to a more accurate estimate of pi.
*/
public class MonteCarlo {
/**
* Main method for driving code and example usage of Monte Carlo Pi Estimation.
*/
public static void main(String[] args) {
// Example: Monte Carlo Pi Estimation
int numSamples = 1000000;
double piEstimate = monteCarloPi(numSamples);
System.out.println("Estimated value of pi using " + numSamples + " samples: " + piEstimate);
}
/**
* Estimate the value of pi using the Monte Carlo method.
*
* @param numSamples Number of random samples to generate.
* @return Estimated value of pi.
*/
public static double monteCarloPi(int numSamples) {
int numPointsInsideCircle = 0;
Random random = new Random();
for (int i = 0; i < numSamples; i++) {
double x = random.nextDouble() * 2 - 1;
double y = random.nextDouble() * 2 - 1;
double distanceSquared = x * x + y * y;
if (distanceSquared <= 1) {
numPointsInsideCircle++;
}
}
return 4.0 * numPointsInsideCircle / numSamples;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/monte-carlo | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/monte-carlo/cpp/main.cpp | #include <iostream>
#include <random>
/**
* MonteCarlo.cpp
*
* The Monte Carlo method is a statistical technique used to estimate numerical results by random sampling.
* In this implementation, we use the Monte Carlo method to estimate the value of pi by simulating random points
* within a unit square and determining the ratio of points that fall within the unit circle.
*
* Algorithm: We generate numSamples random points uniformly distributed within the unit square [-1, 1] x [-1, 1].
* For each point, we calculate its distance from the origin and count how many points fall within the unit circle
* (i.e., have a distance <= 1 from the origin). The ratio of points inside the circle to the total number of points
* approximates the ratio of the area of the unit circle to the area of the unit square, which is π/4.
*
* Implementation: The monteCarloPi function takes the number of samples numSamples as input and iterates through the
* algorithm to estimate the value of pi using the Monte Carlo method. It returns the estimated value of pi.
*
* Example Usage: In the main function, an example usage of the monteCarloPi function is provided. We specify the
* number of samples, call the function to estimate pi, and then print the result. Increasing the number of samples
* generally leads to a more accurate estimate of pi.
*/
/**
* Estimate the value of pi using the Monte Carlo method.
*
* @param numSamples Number of random samples to generate.
* @return Estimated value of pi.
*/
double monteCarloPi(int numSamples) {
int numPointsInsideCircle = 0;
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> dis(-1.0, 1.0);
for (int i = 0; i < numSamples; i++) {
double x = dis(gen);
double y = dis(gen);
double distanceSquared = x * x + y * y;
if (distanceSquared <= 1) {
numPointsInsideCircle++;
}
}
return 4.0 * numPointsInsideCircle / numSamples;
}
int main() {
// Example: Monte Carlo Pi Estimation
int numSamples = 1000000;
double piEstimate = monteCarloPi(numSamples);
std::cout << "Estimated value of pi using " << numSamples << " samples: " << piEstimate << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/monte-carlo | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/monte-carlo/python/monte_carlo.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""monte_carlo.py
The Monte Carlo method is a statistical technique used to estimate numerical results by random sampling. In this implementation, we use the Monte Carlo method to estimate the value of pi by simulating random points within a unit square and determining the ratio of points that fall within the unit circle.
Algorithm: We generate num_samples random points uniformly distributed within the unit square [-1, 1] x [-1, 1]. For each point, we calculate its distance from the origin and count how many points fall within the unit circle (i.e., have a distance <= 1 from the origin). The ratio of points inside the circle to the total number of points approximates the ratio of the area of the unit circle to the area of the unit square, which is π/4.
Implementation: The function monte_carlo_pi takes the number of samples num_samples as input and iterates through the algorithm to estimate the value of pi using the Monte Carlo method. It returns the estimated value of pi.
Example Usage: In the if __name__ == "__main__": block, an example usage of the monte_carlo_pi function is provided. We specify the number of samples, call the function to estimate pi, and then print the result. Increasing the number of samples generally leads to a more accurate estimate of pi.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import random
from typing import Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Monte Carlo Pi Estimation
num_samples = 1000000
pi_estimate = monte_carlo_pi(num_samples)
print(f"Estimated value of pi using {num_samples} samples: {pi_estimate}")
return None
def monte_carlo_pi(num_samples: int) -> float:
"""Estimate the value of pi using the Monte Carlo method.
Args:
num_samples (int): Number of random samples to generate.
Returns:
float: Estimated value of pi.
"""
num_points_inside_circle = 0
for _ in range(num_samples):
x = random.uniform(-1, 1)
y = random.uniform(-1, 1)
distance_squared = x**2 + y**2
if distance_squared <= 1:
num_points_inside_circle += 1
pi_estimate = 4 * num_points_inside_circle / num_samples
return pi_estimate
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting/java/Main.java | import java.util.Arrays;
/**
* Main class to demonstrate least squares fitting.
*/
public class Main {
public static void main(String[] args) {
// Example: Fit a polynomial curve to a set of data points
double[] xValues = {1, 2, 3, 4, 5};
double[] yValues = {2.3, 3.5, 4.2, 5.0, 6.1};
int degree = 2;
double[] coefficients = LeastSquaresFitting.leastSquaresFit(xValues, yValues, degree);
System.out.println("Coefficients of the polynomial curve: " + Arrays.toString(coefficients));
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting/java/LeastSquaresFitting.java | import java.util.Arrays;
/**
* Class to perform least squares fitting.
*/
public class LeastSquaresFitting {
/**
* Perform least squares fitting to find the coefficients of the polynomial curve.
*
* @param xValues The x-coordinates of the data points.
* @param yValues The y-coordinates of the data points.
* @param degree The degree of the polynomial curve to fit.
* @return An array of coefficients in descending order of powers (highest power first).
*/
public static double[] leastSquaresFit(double[] xValues, double[] yValues, int degree) {
int n = xValues.length;
double[][] vandermondeMatrix = new double[n][degree + 1];
// Create the Vandermonde matrix
for (int i = 0; i < n; i++) {
for (int j = 0; j <= degree; j++) {
vandermondeMatrix[i][j] = Math.pow(xValues[i], j);
}
}
double[] coefficients = new double[degree + 1];
double[] residuals = new double[n];
// Perform least squares fitting
coefficients = linearLeastSquares(vandermondeMatrix, yValues);
return coefficients;
}
/**
* Solve the linear least squares problem using normal equations.
*
* @param X The Vandermonde matrix.
* @param y The y-coordinates of the data points.
* @return The coefficients of the polynomial curve.
*/
private static double[] linearLeastSquares(double[][] X, double[] y) {
int rows = X.length;
int cols = X[0].length;
double[][] Xt = new double[cols][rows];
double[][] XtX = new double[cols][cols];
double[] Xty = new double[cols];
// Transpose X
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
Xt[j][i] = X[i][j];
}
}
// Compute XtX and Xty
for (int i = 0; i < cols; i++) {
for (int j = 0; j < cols; j++) {
for (int k = 0; k < rows; k++) {
XtX[i][j] += Xt[i][k] * X[k][j];
}
}
for (int k = 0; k < rows; k++) {
Xty[i] += Xt[i][k] * y[k];
}
}
// Solve XtX * coefficients = Xty using Gaussian elimination
return gaussianElimination(XtX, Xty);
}
/**
* Solve a system of linear equations using Gaussian elimination.
*
* @param A The matrix of coefficients.
* @param b The right-hand side vector.
* @return The solution vector.
*/
private static double[] gaussianElimination(double[][] A, double[] b) {
int n = b.length;
for (int p = 0; p < n; p++) {
int max = p;
for (int i = p + 1; i < n; i++) {
if (Math.abs(A[i][p]) > Math.abs(A[max][p])) {
max = i;
}
}
double[] temp = A[p];
A[p] = A[max];
A[max] = temp;
double t = b[p];
b[p] = b[max];
b[max] = t;
for (int i = p + 1; i < n; i++) {
double alpha = A[i][p] / A[p][p];
b[i] -= alpha * b[p];
for (int j = p; j < n; j++) {
A[i][j] -= alpha * A[p][j];
}
}
}
double[] x = new double[n];
for (int i = n - 1; i >= 0; i--) {
double sum = 0.0;
for (int j = i + 1; j < n; j++) {
sum += A[i][j] * x[j];
}
x[i] = (b[i] - sum) / A[i][i];
}
return x;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(LeastSquaresFitting)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(LeastSquaresFitting main.cpp leastSquaresFitting.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting/cpp/main.cpp | #include <iostream>
#include <vector>
#include "leastSquaresFitting.h"
/**
* Main function to demonstrate least squares fitting.
*/
int main() {
// Example: Fit a polynomial curve to a set of data points
std::vector<double> xValues = {1, 2, 3, 4, 5};
std::vector<double> yValues = {2.3, 3.5, 4.2, 5.0, 6.1};
int degree = 2;
std::vector<double> coefficients = leastSquaresFit(xValues, yValues, degree);
std::cout << "Coefficients of the polynomial curve: ";
for (double coeff : coefficients) {
std::cout << coeff << " ";
}
std::cout << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting/cpp/leastSquaresFitting.h | #ifndef LEAST_SQUARES_FITTING_H
#define LEAST_SQUARES_FITTING_H
#include <vector>
/**
* Perform least squares fitting to find the coefficients of the polynomial curve.
*
* @param xValues The x-coordinates of the data points.
* @param yValues The y-coordinates of the data points.
* @param degree The degree of the polynomial curve to fit.
* @return A vector of coefficients in descending order of powers (highest power first).
*/
std::vector<double> leastSquaresFit(const std::vector<double>& xValues, const std::vector<double>& yValues, int degree);
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/least-squares-fitting/cpp/leastSquaresFitting.cpp | #include "leastSquaresFitting.h"
#include <iostream>
#include <vector>
#include <cmath>
/**
* Perform least squares fitting to find the coefficients of the polynomial curve.
*
* @param xValues The x-coordinates of the data points.
* @param yValues The y-coordinates of the data points.
* @param degree The degree of the polynomial curve to fit.
* @return A vector of coefficients in descending order of powers (highest power first).
*/
std::vector<double> leastSquaresFit(const std::vector<double>& xValues, const std::vector<double>& yValues, int degree) {
int n = xValues.size();
std::vector<std::vector<double>> vandermondeMatrix(n, std::vector<double>(degree + 1, 0.0));
// Create the Vandermonde matrix
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= degree; ++j) {
vandermondeMatrix[i][j] = std::pow(xValues[i], j);
}
}
std::vector<double> coefficients(degree + 1, 0.0);
coefficients = linearLeastSquares(vandermondeMatrix, yValues);
return coefficients;
}
/**
* Solve the linear least squares problem using normal equations.
*
* @param X The Vandermonde matrix.
* @param y The y-coordinates of the data points.
* @return The coefficients of the polynomial curve.
*/
std::vector<double> linearLeastSquares(const std::vector<std::vector<double>>& X, const std::vector<double>& y) {
int rows = X.size();
int cols = X[0].size();
std::vector<std::vector<double>> Xt(cols, std::vector<double>(rows, 0.0));
std::vector<std::vector<double>> XtX(cols, std::vector<double>(cols, 0.0));
std::vector<double> Xty(cols, 0.0);
// Transpose X
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
Xt[j][i] = X[i][j];
}
}
// Compute XtX and Xty
for (int i = 0; i < cols; ++i) {
for (int j = 0; j < cols; ++j) {
for (int k = 0; k < rows; ++k) {
XtX[i][j] += Xt[i][k] * X[k][j];
}
}
for (int k = 0; k < rows; ++k) {
Xty[i] += Xt[i][k] * y[k];
}
}
// Solve XtX * coefficients = Xty using Gaussian elimination
return gaussianElimination(XtX, Xty);
}
/**
* Solve a system of linear equations using Gaussian elimination.
*
* @param A The matrix of coefficients.
* @param b The right-hand side vector.
* @return The solution vector.
*/
std::vector<double> gaussianElimination(std::vector<std::vector<double>>& A, std::vector<double>& b) {
int n = b.size();
for (int p = 0; p < n; ++p) {
int max = p;
for (int i = p + 1; i < n; ++i) {
if (std::abs(A[i][p]) > std::abs(A[max][p])) {
max = i;
}
}
std::swap(A[p], A[max]);
std::swap(b[p], b[max]);
for (int i = p + 1; i < n; ++i) {
double alpha = A[i][p] / A[p][p];
b[i] -= alpha * b[p];
for (int j = p; j < n; ++j) {
A[i][j] -= alpha * A[p][j];
}
}
}
std::vector<double> x(n, 0.0);
for (int i = n - 1; i >= 0; --i) {
double sum = 0.0;
for (int j = i + 1; j < n; ++j) {
sum += A[i][j] * x[j];
}
x[i] = (b[i] - sum) / A[i][i];
}
return x;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference/java/BayesianInference.java | import java.util.HashMap;
import java.util.Map;
/**
* Class to perform Bayesian inference.
*/
public class BayesianInference {
/**
* Perform Bayesian inference to update priors based on likelihoods.
*
* @param priors A map of hypothesis names to their prior probabilities.
* @param likelihoods A map of hypothesis names to their likelihoods.
* @return A map of hypothesis names to their updated probabilities.
*/
public static Map<String, Double> bayesianInference(Map<String, Double> priors, Map<String, Double> likelihoods) {
Map<String, Double> updatedProbs = new HashMap<>();
// Compute the denominator (evidence) by summing the products of priors and likelihoods
double evidence = 0.0;
for (Map.Entry<String, Double> entry : priors.entrySet()) {
String hypothesis = entry.getKey();
evidence += entry.getValue() * likelihoods.get(hypothesis);
}
// Update the probabilities of each hypothesis using Bayes' theorem
for (Map.Entry<String, Double> entry : priors.entrySet()) {
String hypothesis = entry.getKey();
double prior = entry.getValue();
double likelihood = likelihoods.get(hypothesis);
updatedProbs.put(hypothesis, (prior * likelihood) / evidence);
}
return updatedProbs;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference/java/Main.java | import java.util.HashMap;
import java.util.Map;
/**
* Main class to demonstrate Bayesian inference.
*/
public class Main {
public static void main(String[] args) {
// Example: Perform Bayesian inference with given priors and likelihoods
Map<String, Double> priors = new HashMap<>();
priors.put("Hypothesis A", 0.3);
priors.put("Hypothesis B", 0.7);
Map<String, Double> likelihoods = new HashMap<>();
likelihoods.put("Hypothesis A", 0.8);
likelihoods.put("Hypothesis B", 0.4);
Map<String, Double> updatedProbs = BayesianInference.bayesianInference(priors, likelihoods);
System.out.println("Updated probabilities after Bayesian inference:");
for (Map.Entry<String, Double> entry : updatedProbs.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference/cpp/bayesianInference.cpp | #include "bayesianInference.h"
/**
* Perform Bayesian inference to update priors based on likelihoods.
*
* @param priors A map of hypothesis names to their prior probabilities.
* @param likelihoods A map of hypothesis names to their likelihoods.
* @return A map of hypothesis names to their updated probabilities.
*/
std::map<std::string, double> bayesianInference(const std::map<std::string, double> &priors, const std::map<std::string, double> &likelihoods) {
std::map<std::string, double> updatedProbs;
// Compute the denominator (evidence) by summing the products of priors and likelihoods
double evidence = 0.0;
for (const auto &pair : priors) {
const std::string &hypothesis = pair.first;
evidence += pair.second * likelihoods.at(hypothesis);
}
// Update the probabilities of each hypothesis using Bayes' theorem
for (const auto &pair : priors) {
const std::string &hypothesis = pair.first;
double prior = pair.second;
double likelihood = likelihoods.at(hypothesis);
updatedProbs[hypothesis] = (prior * likelihood) / evidence;
}
return updatedProbs;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference/cpp/CMakeLists.txt | cmake_minimum_required(VERSION 3.10)
# Project name
project(BayesianInference)
# Set C++ standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Include directories
include_directories(${PROJECT_SOURCE_DIR})
# Add the executable
add_executable(BayesianInference main.cpp bayesianInference.cpp)
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference/cpp/bayesianInference.h | #ifndef BAYESIAN_INFERENCE_H
#define BAYESIAN_INFERENCE_H
#include <map>
#include <string>
/**
* Perform Bayesian inference to update priors based on likelihoods.
*
* @param priors A map of hypothesis names to their prior probabilities.
* @param likelihoods A map of hypothesis names to their likelihoods.
* @return A map of hypothesis names to their updated probabilities.
*/
std::map<std::string, double> bayesianInference(const std::map<std::string, double> &priors, const std::map<std::string, double> &likelihoods);
#endif
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference | repos/exploratory-tech-studio/tech-studio-projects/algorithms/statistical-analysis/bayesian-inference/cpp/main.cpp | #include <iostream>
#include <map>
#include "bayesianInference.h"
/**
* Main function to demonstrate Bayesian inference.
*/
int main() {
// Example: Perform Bayesian inference with given priors and likelihoods
std::map<std::string, double> priors = {{"Hypothesis A", 0.3}, {"Hypothesis B", 0.7}};
std::map<std::string, double> likelihoods = {{"Hypothesis A", 0.8}, {"Hypothesis B", 0.4}};
std::map<std::string, double> updatedProbs = bayesianInference(priors, likelihoods);
std::cout << "Updated probabilities after Bayesian inference:" << std::endl;
for (const auto &pair : updatedProbs) {
std::cout << pair.first << ": " << pair.second << std::endl;
}
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/root-finding-optimization/newtons-method | repos/exploratory-tech-studio/tech-studio-projects/algorithms/root-finding-optimization/newtons-method/java/NewtonsMethod.java | import java.util.function.DoubleUnaryOperator;
public class NewtonsMethod {
/**
* Find a root of a function using Newton's method.
*
* @param f The function for which to find the root.
* @param df The derivative of the function.
* @param x0 Initial guess for the root.
* @param tol Tolerance for convergence.
* @param maxItr Maximum number of iterations.
* @return The root and the number of iterations.
*/
public static Result newtonsMethod(DoubleUnaryOperator f, DoubleUnaryOperator df, double x0, double tol, int maxItr) {
double x = x0;
double delta_x;
for (int i = 0; i < maxItr; i++) {
delta_x = -f.applyAsDouble(x) / df.applyAsDouble(x);
x += delta_x;
if (Math.abs(delta_x) < tol) {
return new Result(x, i + 1);
}
}
return new Result(x, maxItr);
}
public static void main(String[] args) {
// Example: Find a root of a function using Newton's method
DoubleUnaryOperator f = x -> x * x - 4;
DoubleUnaryOperator df = x -> 2 * x;
double x0 = 2.0;
double tol = 1e-6;
int maxItr = 1000;
Result result = newtonsMethod(f, df, x0, tol, maxItr);
System.out.println("Root: " + result.root);
System.out.println("Number of iterations: " + result.iterations);
}
static class Result {
double root;
int iterations;
Result(double root, int iterations) {
this.root = root;
this.iterations = iterations;
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/root-finding-optimization/newtons-method | repos/exploratory-tech-studio/tech-studio-projects/algorithms/root-finding-optimization/newtons-method/cpp/main.cpp | #include <iostream>
#include <functional>
struct Result {
double root;
int iterations;
};
Result newtonsMethod(std::function<double(double)> f, std::function<double(double)> df, double x0, double tol, int maxItr) {
double x = x0;
double delta_x;
for (int i = 0; i < maxItr; i++) {
delta_x = -f(x) / df(x);
x += delta_x;
if (std::abs(delta_x) < tol) {
return {x, i + 1};
}
}
return {x, maxItr};
}
int main() {
// Example: Find a root of a function using Newton's method
auto f = [](double x) { return x * x - 4; };
auto df = [](double x) { return 2 * x; };
double x0 = 2.0;
double tol = 1e-6;
int maxItr = 1000;
Result result = newtonsMethod(f, df, x0, tol, maxItr);
std::cout << "Root: " << result.root << std::endl;
std::cout << "Number of iterations: " << result.iterations << std::endl;
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/root-finding-optimization/newtons-method | repos/exploratory-tech-studio/tech-studio-projects/algorithms/root-finding-optimization/newtons-method/python/newtons_method.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""newtons_method.py
Newton's method is an iterative root-finding algorithm that starts with an initial guess and refines it iteratively to find a root of a given function. Here's how the algorithm works:
Initialization: Start with an initial guess x0x0.
Iteration: Repeat the following steps until convergence or a maximum number of iterations:
Compute the change in xx using the formula: Δx=−f(x)f′(x)Δx=−f′(x)f(x), where f(x)f(x) is the function and f′(x)f′(x) is its derivative.
Update the value of xx using x:=x+Δxx:=x+Δx.
Check for convergence: If ∣Δx∣<tol∣Δx∣<tol, where tol is a predefined tolerance, exit the loop.
Termination: Return the final value of xx and the number of iterations.
In the example usage, we demonstrate how to find a root of a simple function f(x)=x2−4f(x)=x2−4 using Newton's method. We provide the function f(x)f(x), its derivative f′(x)f′(x), an initial guess x0x0, and call the newtons_method function to obtain the root and the number of iterations required for convergence. Adjustments to the initial guess, tolerance, and maximum number of iterations can be made based on the specific problem being solved.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from typing import Callable, Tuple
import numpy as np
def main() -> None:
"""Driving code and main function"""
# Example: Find a root of a function using Newton's method
def f(x: float) -> float:
return x**2 - 4
def df(x: float) -> float:
return 2 * x
x0 = 2.0
root, iterations = newtons_method(f, df, x0)
print("Root:", root)
print("Number of iterations:", iterations)
return None
def newtons_method(f: Callable[[float], float], df: Callable[[float], float], x0: float, tol: float = 1e-6, max_iter: int = 1000) -> Tuple[float, int]:
"""Find a root of a function using Newton's method.
Args:
f (Callable[[float], float]): The function for which to find the root.
df (Callable[[float], float]): The derivative of the function.
x0 (float): Initial guess for the root.
tol (float, optional): Tolerance for convergence. Defaults to 1e-6.
max_iter (int, optional): Maximum number of iterations. Defaults to 1000.
Returns:
Tuple[float, int]: The root and the number of iterations.
"""
x = x0
for i in range(max_iter):
delta_x = -f(x) / df(x)
x += delta_x
if abs(delta_x) < tol:
break
return x, i + 1
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/dynamic-programming/knapsack-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/dynamic-programming/knapsack-problem/java/Knapsack.java | /**
* The Knapsack problem.
*
* What is the 0/1 Knapsack Problem? We are given N items where each
* item has some weight and profit associated with it. We are also given
* a bag with capacity W, [i.e., the bag can hold at most W weight in it].
* The target is to put the items into the bag such that the sum of
* profits associated with them is the maximum possible.
*
* Note: The constraint here is we can either put an item completely into
* the bag or cannot put it at all [It is not possible to put a part of
* an item into the bag].
*
* Examples:
* Input: N = 3, W = 4, profit[] = {1, 2, 3}, weight[] = {4, 5, 1}
* Output: 3
* Explanation: There are two items which have weight less than or equal
* to 4. If we select the item with weight 4, the possible profit is 1. And
* if we select the item with weight 1, the possible profit is 3. So the
* maximum possible profit is 3. Note that we cannot put both the items
* with weight 4 and 1 together as the capacity of the bag is 4.
*
* Input: N = 3, W = 3, profit[] = {1, 2, 3}, weight[] = {4, 5, 6}
* Output: 0
*/
public class Knapsack {
/**
* A naive recursive implementation of 0-1 Knapsack problem.
*
* @param W Maximum weight the bag can hold.
* @param wt Weight of all subsets.
* @param val Maximum possible profit.
* @param n Number of items the bag can hold.
* @return The maximum value that can be put in a knapsack of capacity W.
*/
public static int knapSack(int W, int[] wt, int[] val, int n) {
// Base Case
if (n == 0 || W == 0) {
return 0;
}
// If weight of the nth item is more than Knapsack capacity W, then
// this item cannot be included in the optimal solution
if (wt[n - 1] > W) {
return knapSack(W, wt, val, n - 1);
} else {
// Return the maximum of two cases:
// (1) nth item included
// (2) not included
return Math.max(
val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1),
knapSack(W, wt, val, n - 1)
);
}
}
public static void main(String[] args) {
int[] val = {1, 2, 3};
int[] wt = {4, 5, 1};
int W = 4;
int n = val.length;
System.out.println(knapSack(W, wt, val, n)); // Output: 3
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/dynamic-programming/knapsack-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/dynamic-programming/knapsack-problem/cpp/main.cpp | /**
* The Knapsack problem.
*
* What is the 0/1 Knapsack Problem? We are given N items where each
* item has some weight and profit associated with it. We are also given
* a bag with capacity W, [i.e., the bag can hold at most W weight in it].
* The target is to put the items into the bag such that the sum of
* profits associated with them is the maximum possible.
*
* Note: The constraint here is we can either put an item completely into
* the bag or cannot put it at all [It is not possible to put a part of
* an item into the bag].
*
* Examples:
* Input: N = 3, W = 4, profit[] = {1, 2, 3}, weight[] = {4, 5, 1}
* Output: 3
* Explanation: There are two items which have weight less than or equal
* to 4. If we select the item with weight 4, the possible profit is 1. And
* if we select the item with weight 1, the possible profit is 3. So the
* maximum possible profit is 3. Note that we cannot put both the items
* with weight 4 and 1 together as the capacity of the bag is 4.
*
* Input: N = 3, W = 3, profit[] = {1, 2, 3}, weight[] = {4, 5, 6}
* Output: 0
*/
#include <iostream>
#include <algorithm>
// A naive recursive implementation of 0-1 Knapsack problem.
int knapSack(int W, int wt[], int val[], int n) {
// Base Case
if (n == 0 || W == 0) {
return 0;
}
// If weight of the nth item is more than Knapsack capacity W, then
// this item cannot be included in the optimal solution
if (wt[n - 1] > W) {
return knapSack(W, wt, val, n - 1);
} else {
// Return the maximum of two cases:
// (1) nth item included
// (2) not included
return std::max(
val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1),
knapSack(W, wt, val, n - 1)
);
}
}
int main() {
int val[] = {1, 2, 3};
int wt[] = {4, 5, 1};
int W = 4;
int n = sizeof(val) / sizeof(val[0]);
std::cout << knapSack(W, wt, val, n) << std::endl; // Output: 3
return 0;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/dynamic-programming/knapsack-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/dynamic-programming/knapsack-problem/python/knapsack_problem.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""The Knapsack problem.
What is the 0/1 Knapsack Problem? We are given N items where each
item has some weight and profit associated with it. We are also given
a bag with capacity W, [i.e., the bag can hold at most W weight in it].
The target is to put the items into the bag such that the sum of
profits associated with them is the maximum possible.
Note: The constraint here is we can either put an item completely into
the bag or cannot put it at all [It is not possible to put a part of
an item into the bag].
Examples:
Input: N = 3, W = 4, profit[] = {1, 2, 3}, weight[] = {4, 5, 1}
Output: 3
Explanation: There are two items which have weight less than or equal
to 4. If we select the item with weight 4, the possible profit is 1. And
if we select the item with weight 1, the possible profit is 3. So the
maximum possible profit is 3. Note that we cannot put both the items
with weight 4 and 1 together as the capacity of the bag is 4.
Input: N = 3, W = 3, profit[] = {1, 2, 3}, weight[] = {4, 5, 6}
Output: 0
.. _PEP 484:
https://www.python.org/dev/peps/pep-0484/
.. _Google Python Style Guide:
http://google.github.io/styleguide/pyguide.html
.. _Original source:
https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/
"""
def knap_sack(W: int, wt: list, val: list, n: int):
"""Naive knapsack recurisve implementation of
0-1 Knapsack problem.
Returns the maximum value that can be put in a knapsack of
capacity W.
Knapsack Problem using recursion:
---------------------------------
To solve the problem follow the below idea:
A simple solution is to consider all subsets of items and calculate the total weight and
profit of all subsets. Consider the only subsets whose total weight is smaller than W.
From all such subsets, pick the subset with maximum profit.
Optimal Substructure: To consider all subsets of items, there can be two cases for every item.
Case 1: The item is included in the optimal subset.
Case 2: The item is not included in the optimal set.
Follow the below steps to solve the problem:
The maximum value obtained from 'N' items is the max of the following two values.
Maximum value obtained by N-1 items and W weight (excluding nth item)
Value of nth item plus maximum value obtained by N-1 items and (W - weight of the Nth item) [including Nth item].
If the weight of the 'Nth' item is greater than 'W', then the Nth item cannot be included and Case 1 is the only possibility.
Args:
W (int): Maximum weight the bag can hold.
wt (list): Weight o fall subsets.
val (list): Maximum possible profit.
n (int): Number of items the bag can hold.
Returns:
function: Return debugger function.
"""
# Base Case
if n == 0 or W == 0:
return 0
# If weight of the nth item is
# more than Knapsack of capacity W,
# then this item cannot be included
# in the optimal solution
if (wt[n-1] > W):
return knap_sack(W, wt, val, n-1)
# return the maximum of two cases:
# (1) nth item included
# (2) not included
else:
return max(
val[n-1] + knap_sack(
W-wt[n-1], wt, val, n-1),
knap_sack(W, wt, val, n-1)) |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/DFS.java | package PathFinding_DFS;
import java.util.*;
public class DFS {
private Stack<Node> myStack;
private List<Node> nodeVisited; //
private int startNodeIndex;//
private int targetNodeIndex;//
private boolean targetFound;//
public DFS() {
this.myStack = new Stack<>();
this.nodeVisited = new ArrayList<>(); //
targetFound = false; //
}
public List<Node> dfs(Graph g , int startNodeIndex , int targetNodeIndex) { //
List<Node> nodeList = g.getAllNodes(); //
this.startNodeIndex = startNodeIndex; //
this.targetNodeIndex = targetNodeIndex; //
dfsInStack(nodeList.get(this.startNodeIndex - 1)); //
return this.nodeVisited; //
}
private void dfsInStack(Node root) {
this.myStack.push(root);
root.setVisited(true); //
while (this.myStack.isEmpty() == false) {
Node currentNode = this.myStack.pop();
if ((int) currentNode.getElement() == this.targetNodeIndex ) { //
this.targetFound = true; //
return; //
}else //
{ //
this.nodeVisited.add(currentNode); //
} //
// System.out.println("Current node: " + currentNode.getElement().toString() );
for (int i = currentNode.getNeighbours().size()-1 ; i >=0 ; i--) {
Node n = currentNode.getNeighbours().get(i);
if (n.isVisited() == false) {
n.setVisited(true);
this.myStack.push(n);
}
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/FinalPath.java | package PathFinding_DFS;
import java.awt.*;
import java.util.List;
import javax.swing.*;
public class FinalPath extends JComponent{
private List<Node> nodeVisited;
private Maze maze;
public FinalPath(Maze maze , List<Node> nodeVisited) {
this.maze = maze;
this.nodeVisited = nodeVisited;
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g.create();
int mazeColNo = maze.getColNo();
int mazeRowNo = maze.getRowNo();
int blockSize = maze.getBlockSize();
for (int i = 0; i < mazeRowNo; i++) {
for (int j = 0; j < mazeColNo; j++) {
Color color;
switch (maze.getMaze()[i][j]) {
case 1 : // Walls
color = Color.GRAY;
break;
case -1: // Start
color = Color.RED;
break;
case 9 : // End
color = Color.BLUE;
break;
default : // Others
color = Color.WHITE;
}
g2.setColor(color);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
g2.setColor(Color.BLACK);
g2.drawRect(blockSize * j, blockSize * i, blockSize, blockSize);
}
}
int idx, i , j;
int nodeOrder = 0;
for (Node n : nodeVisited) {
idx = (int) n.getElement();
i = idx / (mazeColNo);
j = idx % (mazeColNo)-1;
g2.setColor(Color.ORANGE);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
g2.setColor(Color.BLACK);
g2.drawString(nodeOrder+ "", blockSize * j + blockSize/2, blockSize * i + blockSize/2);
nodeOrder++;
}
Node n = nodeVisited.get(0);
idx = (int) n.getElement();
i = idx / (mazeColNo);
j = idx % (mazeColNo)-1;
g2.setColor(Color.RED);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
g2.setColor(Color.BLACK);
g2.drawString(0+ "", blockSize * j + blockSize/2, blockSize * i + blockSize/2);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/Maze.java | package PathFinding_DFS;
/*
** file: ABox.java
** purpose: A component that paints a red box.
*/
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
public class Maze extends JComponent {
private int [][] maze =
{ {1,1,1,1,1,1,1,1,1,1,1,1,1},
{1,-1,1,0,1,0,1,0,0,0,0,0,1},
{1,0,1,0,0,0,1,0,1,1,1,0,1},
{1,0,0,0,1,1,1,0,0,0,0,0,1},
{1,1,1,0,0,0,0,0,1,1,1,0,1},
{1,0,1,1,1,1,1,0,1,0,0,0,1},
{1,0,1,0,1,0,0,0,1,1,1,0,1},
{1,0,1,0,1,1,1,0,1,0,1,0,1},
{1,0,0,0,0,0,0,0,0,0,1,9,1},
{1,1,1,1,1,1,1,1,1,1,1,1,1}
};
private int[][] indexMatrix;
private Node[][] nodesMatrix;
private Graph g;
private int colNo;
private int rowNo;
private int blockSize;
public Maze() {
this.blockSize = 40;
this.rowNo = maze.length;
this.colNo = maze[0].length;
this.g = new Graph();
nodesMatrix = new Node[this.rowNo][this.colNo];
int idx = 1;
for (int i = 0; i < this.rowNo; i++) {
for (int j = 0; j < this.colNo; j++) {
//this.indexMatrix[i][j] = idx;
this.nodesMatrix[i][j] = new Node (idx);
idx++;
}
}
createGraph();
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g.create();
// draw the maze
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze[0].length; j++) {
Color color;
switch (maze[i][j]) {
case 1 :
color = Color.GRAY;
break;
case -1: // Start
color = Color.RED;
break;
case 9 :
color = Color.BLUE;
break;
default :
color = Color.WHITE;
}
g2.setColor(color);
g2.fillRect(this.blockSize * j, this.blockSize * i, this.blockSize, this.blockSize);
g2.setColor(Color.GREEN);
g2.drawString(this.nodesMatrix[i][j].getElement()+ " ", this.blockSize * j + this.blockSize/2, this.blockSize * i + this.blockSize/2);
g2.setColor(Color.BLACK);
g2.drawRect(this.blockSize * j, this.blockSize * i, this.blockSize, this.blockSize);
}
}
}
private void createGraph() {
List<Node> allNodes = new ArrayList<>();
for (int i = 0; i < this.rowNo; i++) {
for (int j = 0; j < this.colNo; j++) {
if (this.maze[i][j] == 1) {
nodesMatrix[i][j].setVisited(true);
}
findAddNeighbours(i,j);
allNodes.add(nodesMatrix[i][j]);
}
}
g.setAllNodes(allNodes);
}
private void findAddNeighbours(int row, int col) {
int colNum = col ;
int rowNum = row ;
if(withinGrid (colNum+1, rowNum , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum][colNum+1]);
}
if(withinGrid (colNum, rowNum+1 , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum+1][colNum]);
}
if(withinGrid (colNum-1, rowNum , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum][colNum-1]);
}
if(withinGrid (colNum, rowNum-1 , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum-1][colNum]);
}
}
private boolean withinGrid(int colNum, int rowNum, int maxRow, int maxCol) {
if((colNum < 0) || (rowNum <0) ) {
return false;
}
if((colNum >= maxCol) || (rowNum >= maxRow)) {
return false;
}
return true;
}
public Graph getGraph() {
return this.g;
}
public int getColNo() {
return colNo;
}
public int getRowNo() {
return rowNo;
}
public int getBlockSize() {
return blockSize;
}
public int[][] getMaze() {
return maze;
}
public int getStartingPoint() {
int idx = 1;
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze[0].length; j++) {
idx++;
if (maze[i][j] == -1) {
return idx-1;
}
}
}
return 1;
}
public int getTargetPoint() {
int idx = 1;
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze[0].length; j++) {
idx++;
if (maze[i][j] == 9) {
return idx-1;
}
}
}
return 1;
}
}
// Diagonal Movements
//private void findAddNeighbours(int row, int col) {
//
// //List<Integer> neighboursList = new ArrayList<>();
// for (int colNum = col - 1 ; colNum <= (col + 1) ; colNum +=1 ) {
// for (int rowNum = row - 1 ; rowNum <= (row + 1) ; rowNum +=1 ) {
//
// //if not the center cell
// if(! ((colNum == col) && (rowNum == row))) {
//
// //make sure it is within grid
// if(withinGrid (colNum, rowNum , this.rowNo, this.colNo)) {
//
// nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum][colNum]);
// //System.out.println("Neighbor of "+ col+ " "+ row + " - " + colNum +" " + rowNum );
// }
// }
// }
// }
//
//
//}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/Main.java | public class Main {
public static void main(String[] args) {
System.out.println("Hello world!");
}
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/Node.java | package PathFinding_DFS;
import java.util.*;
public class Node {
// Attributes
private Object element;
private boolean visited;
private List<Node> neighbours;
// Methods
public Node(Object e) {
this.element = e;
this.visited = false;
this.neighbours = new ArrayList<>();
}
public boolean isVisited() {
return this.visited;
}
public void addNeighbour(Node n) {
this.neighbours.add(n);
}
public Object getElement() {
return element;
}
public void setElement(Object element) {
this.element = element;
}
public List<Node> getNeighbours() {
return neighbours;
}
public void setNeighbours(List<Node> neighbours) {
this.neighbours = neighbours;
}
public void setVisited( boolean status ) {
this.visited = status;
}
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/Graph.java | package PathFinding_DFS;
import java.util.*;
public class Graph {
// Attributes
private List<Node> allNodes;
// Methods
public Graph() {
this.allNodes = new ArrayList<>();
}
public void setAllNodes(List<Node> allNodes) {
this.allNodes = allNodes;
}
public List<Node> getAllNodes(){
return this.allNodes;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/java/SolveMaze.java | package PathFinding_DFS;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
public class SolveMaze {
public static void main(String[] args) {
// Draw the maze
JFrame f = new JFrame("Maze");
f.setSize(600, 500);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Maze maze = new Maze();
f.add(maze);
f.setVisible(true);
Graph g = maze.getGraph();
DFS defSearchEngine = new DFS();
List<Node> nodeVisited = new ArrayList<>();
nodeVisited = defSearchEngine.dfs(g , maze.getStartingPoint(), maze.getTargetPoint());
for (Node n : nodeVisited) {
System.out.println("Node" +n.getElement().toString());
}
System.out.println("Search is done!");
FinalPath finalPath = new FinalPath(maze,nodeVisited);
JFrame f2 = new JFrame("Path to the goal");
f2.setSize(600, 500);
f2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f2.add(finalPath);
f2.setVisible(true);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/depth-first-search/python/depth_first_search.py | # Python program to print DFS traversal for complete graph
from collections import defaultdict
# This class represents a directed graph using adjacency
# list representation
class Graph:
# Constructor
def __init__(self):
# default dictionary to store graph
self.graph = defaultdict(list)
# function to add an edge to graph
def addEdge(self,u,v):
self.graph[u].append(v)
# A function used by DFS
def DFSUtil(self, v, visited):
# Mark the current node as visited and print it
visited[v]= True
print(v)
# Recur for all the vertices adjacent to
# this vertex
for i in self.graph[v]:
if visited[i] == False:
self.DFSUtil(i, visited)
# The function to do DFS traversal. It uses
# recursive DFSUtil()
def DFS(self):
V = len(self.graph) #total vertices
# Mark all the vertices as not visited
visited =[False]*(V)
# Call the recursive helper function to print
# DFS traversal starting from all vertices one
# by one
for i in range(V):
if visited[i] == False:
self.DFSUtil(i, visited)
# Driver code
# Create a graph given in the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
print("Following is Depth First Traversal")
g.DFS()
# This code is contributed by Neelam Yadav
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search/java/Main.java |
import java.util.*;
public class Main {
public static void main(String[] args) {
// Prepare the graph
Graph g = new Graph();
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
Node n4 = new Node(4);
Node n5 = new Node(5);
Node n6 = new Node(6);
Node n7 = new Node(7);
n1.addNeighbour(n2);
n1.addNeighbour(n3);
n2.addNeighbour(n4);
n2.addNeighbour(n5);
n3.addNeighbour(n6);
n3.addNeighbour(n7);
List<Node> allNodes = new ArrayList<>();
allNodes.add(n1);
allNodes.add(n2);
allNodes.add(n3);
allNodes.add(n4);
allNodes.add(n5);
allNodes.add(n6);
allNodes.add(n7);
g.setAllNodes(allNodes);
// BFS the graph
BFS dfsSearchEngine = new BFS();
dfsSearchEngine.bfs(g);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search/java/Node.java | import java.util.*;
public class Node {
// Attributes
private Object element;
private boolean visited;
private List<Node> neighbours;
// Methods
public Node(Object e) {
this.element = e;
this.visited = false;
this.neighbours = new ArrayList<>();
}
public boolean isVisited() {
return this.visited;
}
public void addNeighbour(Node n) {
this.neighbours.add(n);
}
public Object getElement() {
return element;
}
public void setElement(Object element) {
this.element = element;
}
public List<Node> getNeighbours() {
return neighbours;
}
public void setNeighbours(List<Node> neighbours) {
this.neighbours = neighbours;
}
public void setVisited( boolean status ) {
this.visited = status;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search/java/Graph.java | import java.util.*;
public class Graph {
// Attributes
private List<Node> allNodes;
// Methods
public Graph() {
this.allNodes = new ArrayList<>();
}
public void setAllNodes(List<Node> allNodes) {
this.allNodes = allNodes;
}
public List<Node> getAllNodes(){
return this.allNodes;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search/java/BFS.java | import java.util.*;
public class BFS {
// Attributes
private Queue<Node> myQueue;
// Methods
public BFS() {
this.myQueue = new LinkedList<>();
}
public void bfs(Graph g) {
List<Node> nodeList = g.getAllNodes();
for (Node n : nodeList) {
if (n.isVisited() == false) {
n.setVisited(true);
bsfInQueue(n);
}
}
}
private void bsfInQueue(Node root) {
this.myQueue.add(root);
root.setVisited(true);
while(this.myQueue.isEmpty() == false) {
Node currentNode = this.myQueue.remove();
System.out.println("Current node: " + currentNode.getElement().toString());
for (Node n : currentNode.getNeighbours()) {
if (n.isVisited() == false) {
n.setVisited(true);
this.myQueue.add(n);
}
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/breadth-first-search/python/breadth_first_search.py | # Python3 Program to print BFS traversal
# from a given source vertex. BFS(int s)
# traverses vertices reachable from s.
from collections import defaultdict
# This class represents a directed graph
# using adjacency list representation
class Graph:
# Constructor
def __init__(self):
# default dictionary to store graph
self.graph = defaultdict(list)
# function to add an edge to graph
# Make a list visited[] to check if a node is already visited or not
def addEdge(self,u,v):
self.graph[u].append(v)
self.visited=[]
# Function to print a BFS of graph
def BFS(self, s):
# Create a queue for BFS
queue = []
# Add the source node in
# visited and enqueue it
queue.append(s)
self.visited.append(s)
while queue:
# Dequeue a vertex from
# queue and print it
s = queue.pop(0)
print (s, end = " ")
# Get all adjacent vertices of the
# dequeued vertex s. If a adjacent
# has not been visited, then add it
# in visited and enqueue it
for i in self.graph[s]:
if i not in self.visited:
queue.append(i)
self.visited.append(s)
# Driver code
# Create a graph given in
# the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
print ("Following is Breadth First Traversal"
" (starting from vertex 2)")
g.BFS(2)
# This code is contributed by Neelam Yadav
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search/java/GFG.java | import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
public class GFG {
// graph
static List<List<Integer>> graph = new ArrayList<List<Integer>>();
// map to store cost of edges
static HashMap<List<Integer>, Integer> cost = new HashMap<List<Integer>, Integer>();
// returns the minimum cost in a vector( if
// there are multiple goal states)
static List<Integer> uniform_cost_search(List<Integer> goal, int start) {
// minimum cost upto
// goal state from starting
// state
List<Integer> answer = new ArrayList<Integer>();
// create a priority queue
List<Tuple<Integer, Integer>> queue = new ArrayList<Tuple<Integer, Integer>>();
// set the answer vector to max value
for (int i = 0; i < goal.size(); i++)
answer.add(Integer.MAX_VALUE);
// insert the starting index
queue.add(new Tuple<Integer, Integer>(0, start));
// map to store visited node
HashMap<Integer, Integer> visited = new HashMap<Integer, Integer>();
// count
int count = 0;
// while the queue is not empty
while (!queue.isEmpty()) {
// get the top element of the
// priority queue
Tuple<Integer, Integer> q = queue.get(0);
Tuple<Integer, Integer> p = new Tuple<Integer, Integer>(-q.x, q.y);
// pop the element
queue.remove(0);
if (goal.contains(p.y)) {
// get the position
int index = goal.indexOf(p.y);
// if a new goal is reached
if (answer.get(index) == Integer.MAX_VALUE)
count++;
// if the cost is less
if (answer.get(index) > p.x)
answer.set(index, p.x);
// pop the element
queue.remove(0);
// if all goals are reached
if (count == goal.size())
return answer;
}
if (!visited.containsKey(p.y))
for (int i = 0; i < graph.get(p.y).size(); i++) {
// value is multiplied by -1 so that
// least priority is at the top
queue.add(new Tuple<Integer, Integer>((p.x + (cost.containsKey(Arrays.asList(p.y, graph.get(p.y).get(i))) ? cost.get(Arrays.asList(p.y, graph.get(p.y).get(i))) : 0)) * -1,
graph.get(p.y).get(i)));
}
// mark as visited
visited.put(p.y, 1);
}
return answer;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search/java/Main.java | import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
public class Main {
public static void main(String[] args) {
// graph
List<List<Integer>> graph = new ArrayList<List<Integer>>();
// cost
HashMap<List<Integer>, Integer> cost = new HashMap<List<Integer>, Integer>();
// create the graph
graph = new ArrayList<List<Integer>>();
for (int i = 0; i < 7; i++) {
graph.add(new ArrayList<Integer>());
}
// add edges
graph.get(0).add(1);
graph.get(0).add(3);
graph.get(3).add(1);
graph.get(3).add(6);
graph.get(3).add(4);
graph.get(1).add(6);
graph.get(4).add(2);
graph.get(4).add(5);
graph.get(2).add(1);
graph.get(5).add(2);
graph.get(5).add(6);
graph.get(6).add(4);
// add the cost
cost.put(Arrays.asList(0, 1), 2);
cost.put(Arrays.asList(0, 3), 5);
cost.put(Arrays.asList(1, 6), 1);
cost.put(Arrays.asList(3, 1), 5);
cost.put(Arrays.asList(3, 6), 6);
cost.put(Arrays.asList(3, 4), 2);
cost.put(Arrays.asList(2, 1), 4);
cost.put(Arrays.asList(4, 2), 4);
cost.put(Arrays.asList(4, 5), 3);
cost.put(Arrays.asList(5, 2), 6);
cost.put(Arrays.asList(5, 6), 3);
cost.put(Arrays.asList(6, 4), 7);
// goal state
List<Integer> goal = new ArrayList<Integer>();
goal.add(6);
List<Integer> answer = GFG.uniform_cost_search(goal, 0);
// print the answer
System.out.print("Minimum cost from 0 to 6 is = " + answer.get(0));
}
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search/java/Tuple.java | class Tuple<X, Y> {
public final X x;
public final Y y;
public Tuple(X x, Y y) {
this.x = x;
this.y = y;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/uninformed-search/uniform-cost-search/python/uniform_cost_search.py | # Python3 implementation of above approach
# returns the minimum cost in a vector( if
# there are multiple goal states)
def uniform_cost_search(goal, start):
# minimum cost upto
# goal state from starting
global graph,cost
answer = []
# create a priority queue
queue = []
# set the answer vector to max value
for i in range(len(goal)):
answer.append(10**8)
# insert the starting index
queue.append([0, start])
# map to store visited node
visited = {}
# count
count = 0
# while the queue is not empty
while (len(queue) > 0):
# get the top element of the
queue = sorted(queue)
p = queue[-1]
# pop the element
del queue[-1]
# get the original value
p[0] *= -1
# check if the element is part of
# the goal list
if (p[1] in goal):
# get the position
index = goal.index(p[1])
# if a new goal is reached
if (answer[index] == 10**8):
count += 1
# if the cost is less
if (answer[index] > p[0]):
answer[index] = p[0]
# pop the element
del queue[-1]
queue = sorted(queue)
if (count == len(goal)):
return answer
# check for the non visited nodes
# which are adjacent to present node
if (p[1] not in visited):
for i in range(len(graph[p[1]])):
# value is multiplied by -1 so that
# least priority is at the top
queue.append( [(p[0] + cost[(p[1], graph[p[1]][i])])* -1, graph[p[1]][i]])
# mark as visited
visited[p[1]] = 1
return answer
# main function
if __name__ == '__main__':
# create the graph
graph,cost = [[] for i in range(8)],{}
# add edge
graph[0].append(1)
graph[0].append(3)
graph[3].append(1)
graph[3].append(6)
graph[3].append(4)
graph[1].append(6)
graph[4].append(2)
graph[4].append(5)
graph[2].append(1)
graph[5].append(2)
graph[5].append(6)
graph[6].append(4)
# add the cost
cost[(0, 1)] = 2
cost[(0, 3)] = 5
cost[(1, 6)] = 1
cost[(3, 1)] = 5
cost[(3, 6)] = 6
cost[(3, 4)] = 2
cost[(2, 1)] = 4
cost[(4, 2)] = 4
cost[(4, 5)] = 3
cost[(5, 2)] = 6
cost[(5, 6)] = 3
cost[(6, 4)] = 7
# goal state
goal = []
# set the goal
# there can be multiple goal states
goal.append(6)
# get the answer
answer = uniform_cost_search(goal, 0)
# print the answer
print("Minimum cost from 0 to 6 is = ",answer[0]) |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/DrawHeuristic.java | package AGraphSearch;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JComponent;
public class DrawHeuristic extends JComponent {
private Maze maze;
private Node[][] heuristicMatrix;
public DrawHeuristic(Maze maze ) {
this.maze = maze;
this.heuristicMatrix = maze.getNodeMatrix();
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g.create();
int mazeColNo = maze.getColNo();
int mazeRowNo = maze.getRowNo();
int blockSize = maze.getBlockSize();
for (int i = 0; i < mazeRowNo; i++) {
for (int j = 0; j < mazeColNo; j++) {
Color color = null;
switch (maze.getMaze()[i][j]) {
case 1 : // Walls
color = Color.GRAY;
break;
}
g2.setColor(color);
g2.fillRect(blockSize * j, blockSize * i,
blockSize, blockSize);
Color c = new Color((int)
this.heuristicMatrix[i][j].gethValue()*10 %255,0,0);
g2.setColor(c);
g2.fillRect(blockSize * j, blockSize * i,
blockSize, blockSize);
g2.setColor(Color.WHITE);
g2.drawString(Math.round(
this.heuristicMatrix[i][j].gethValue()) + "",
blockSize * j + blockSize/2, blockSize * i + blockSize/2);
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/FinalPath.java | package AGraphSearch;
import java.awt.*;
import java.util.List;
import javax.swing.*;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
public class FinalPath extends JComponent{
private List<Node> nodeVisited;
private Maze maze;
public FinalPath(Maze maze , List<Node> nodeVisited) {
this.maze = maze;
this.nodeVisited = nodeVisited;
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g.create();
int mazeColNo = maze.getColNo();
int mazeRowNo = maze.getRowNo();
int blockSize = maze.getBlockSize();
for (int i = 0; i < mazeRowNo; i++) {
for (int j = 0; j < mazeColNo; j++) {
Color color;
switch (maze.getMaze()[i][j]) {
case 1 : // Walls
color = Color.GRAY;
break;
case -1: // Start
color = Color.RED;
break;
case 9 : // End
color = Color.BLUE;
break;
default : // Others
color = Color.WHITE;
}
g2.setColor(color);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
g2.setColor(Color.BLACK);
g2.drawRect(blockSize * j, blockSize * i, blockSize, blockSize);
}
}
int idx, i , j;
int nodeOrder = 0;
for (Node n : nodeVisited) {
idx = (int) n.getElement();
i = idx / (mazeColNo);
j = idx % (mazeColNo)-1;
g2.setColor(Color.ORANGE);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
g2.setColor(Color.BLACK);
g2.drawString( nodeOrder+ "", blockSize * j + blockSize/2, blockSize * i + blockSize/2);
nodeOrder++;
}
Node n = nodeVisited.get(0);
idx = (int) n.getElement();
i = idx / (mazeColNo);
j = idx % (mazeColNo)-1;
g2.setColor(Color.RED);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
// NEW
g2.setColor(Color.BLACK);
g2.drawString(0+ "", blockSize * j + blockSize/2,
blockSize * i + blockSize/2);
// Last block blue
n = nodeVisited.get(nodeVisited.size()-1);
idx = (int) n.getElement();
i = idx / (mazeColNo);
j = idx % (mazeColNo)-1;
g2.setColor(Color.BLUE);
g2.fillRect(blockSize * j, blockSize * i, blockSize, blockSize);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/Maze.java | package AGraphSearch;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
public class Maze extends JComponent {
private int [][] maze =
{ {1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,9,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1},
{1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
};
private Node[][] nodesMatrix;
private Graph g;
private int colNo;
private int rowNo;
private int blockSize;
public Maze() {
this.blockSize = 40;
this.rowNo = maze.length;
this.colNo = maze[0].length;
this.g = new Graph();
nodesMatrix = new Node[this.rowNo][this.colNo];
int idx = 1;
for (int i = 0; i < this.rowNo; i++) {
for (int j = 0; j < this.colNo; j++) {
this.nodesMatrix[i][j] = new Node (idx);
idx++;
}
}
createGraph();
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g.create();
// draw the maze
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze[0].length; j++) {
Color color;
switch (maze[i][j]) {
case 1 :
color = Color.GRAY;
break;
case -1: // Start
color = Color.RED;
break;
case 9 :
color = Color.BLUE;
break;
default :
color = Color.WHITE;
}
g2.setColor(color);
g2.fillRect(this.blockSize * j, this.blockSize * i, this.blockSize, this.blockSize);
g2.setColor(Color.GREEN);
g2.drawString(this.nodesMatrix[i][j].getElement()+ " ", this.blockSize * j + this.blockSize/2, this.blockSize * i + this.blockSize/2);
g2.setColor(Color.BLACK);
g2.drawRect(this.blockSize * j, this.blockSize * i, this.blockSize, this.blockSize);
}
}
}
private void createGraph() {
List<Node> allNodes = new ArrayList<>();
/////////////////////////////////NEW NEW NEW ////////////////////////////////////////////////
int idx = getTargetPoint();
int iTarget = idx / (this.colNo);
int jTarget = idx % (this.colNo)-1;
for (int i = 0; i < this.rowNo; i++) {
for (int j = 0; j < this.colNo; j++) {
/////////////////////////////////NEW NEW NEW ////////////////////////////////////////////////
double dx = i - iTarget;
double dy = j - jTarget;
this.nodesMatrix[i][j].sethValue(Math.sqrt(dx*dx + dy*dy));
/////////////////////////////////NEW NEW NEW ////////////////////////////////////////////////
if (this.maze[i][j] == 1) {
nodesMatrix[i][j].setVisited(true);
}
findAddNeighbours(i,j);
allNodes.add(nodesMatrix[i][j]);
}
}
g.setAllNodes(allNodes);
}
private void findAddNeighbours(int row, int col) {
int colNum = col ;
int rowNum = row ;
if(withinGrid (colNum+1, rowNum , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum][colNum+1]);
}
if(withinGrid (colNum, rowNum+1 , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum+1][colNum]);
}
if(withinGrid (colNum-1, rowNum , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum][colNum-1]);
}
if(withinGrid (colNum, rowNum-1 , this.rowNo, this.colNo)) {
nodesMatrix[row][col].addNeighbour(this.nodesMatrix[rowNum-1][colNum]);
}
}
private boolean withinGrid(int colNum, int rowNum, int maxRow, int maxCol) {
if((colNum < 0) || (rowNum <0) ) {
return false;
}
if((colNum >= maxCol) || (rowNum >= maxRow)) {
return false;
}
return true;
}
public Graph getGraph() {
return this.g;
}
public int getColNo() {
return colNo;
}
public int getRowNo() {
return rowNo;
}
public int getBlockSize() {
return blockSize;
}
public int[][] getMaze() {
return maze;
}
public int getStartingPoint() {
int idx = 1;
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze[0].length; j++) {
idx++;
if (maze[i][j] == -1) {
return idx-1;
}
}
}
return 1;
}
public int getTargetPoint() {
int idx = 1;
for (int i = 0; i < maze.length; i++) {
for (int j = 0; j < maze[0].length; j++) {
idx++;
if (maze[i][j] == 9) {
return idx-1;
}
}
}
return 1;
}
/////////////////////////////////NEW NEW NEW ////////////////////////////////////////////////
public Node[][] getNodeMatrix() {
return this.nodesMatrix;
}
/////////////////////////////////NEW NEW NEW ////////////////////////////////////////////////
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/Node.java | package AGraphSearch;
import java.util.*;
public class Node {
// Attributes
private Object element;
private boolean visited;
private List<Node> neighbours;
//new
private double hValue;
private double gValue;
private double fValue;
// Methods
/////////////////////////////NEW NEW NEW //////////////////////////
public Node(Object e) {
this.element = e;
this.visited = false;
this.neighbours = new ArrayList<>();
this.hValue = 0;
this.gValue = 0;
this.fValue = 0;
}
public void sethValue(double hValue) {
this.hValue = hValue;
}
public double gethValue() {
return this.hValue;
}
public double getgValue() {
return gValue;
}
public void setgValue(double gValue) {
this.gValue = gValue;
}
public double getfValue() {
return fValue;
}
public void setfValue(double fValue) {
this.fValue = fValue;
}
/////////////////////////////End new //////////////////////////
public boolean isVisited() {
return this.visited;
}
public void addNeighbour(Node n) {
this.neighbours.add(n);
}
public Object getElement() {
return element;
}
public void setElement(Object element) {
this.element = element;
}
public List<Node> getNeighbours() {
return neighbours;
}
public void setNeighbours(List<Node> neighbours) {
this.neighbours = neighbours;
}
public void setVisited( boolean status ) {
this.visited = status;
}
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/AStar.java | package AGraphSearch;
import java.util.*;
public class AStar {
private int startNodeIndex;
private int targetNodeIndex;
private PriorityQueue<Node> openSet;
private boolean[] closedSet;
public AStar(){
openSet = new PriorityQueue<Node>( (Node n1, Node n2) -> {
if ( n1.getfValue() < n2.getfValue() ) {
return -1;
}
else if(n1.getfValue() > n2.getfValue()) {
return 1;
}
else {
return 0;
}
});
}
public List<Node> search(Graph myGraph ,
int startNodeIndex , int targetNodeIndex) {
List<Node> nodeVisited = new ArrayList<>();
this.startNodeIndex = startNodeIndex;
this.targetNodeIndex = targetNodeIndex;
List<Node> nodeList = myGraph.getAllNodes();
closedSet = new boolean[nodeList.size()];
Node root = nodeList.get(this.startNodeIndex - 1);
List<Node> neighbours = null;
root.setgValue(0);
root.setVisited(true);
openSet.add(root);
Node current;
while(true) {
current = openSet.poll();
nodeVisited.add(current);
if (current == null) {
break;
}
this.closedSet[(int) current.getElement()-1] = true;
if((int) current.getElement() == this.targetNodeIndex ) {
return nodeVisited;
}
neighbours = current.getNeighbours();
for (Node n : neighbours) {
updateOpenSetIfNeeded(current, n);
}
}
return nodeVisited;
}
public void updateOpenSetIfNeeded(Node current, Node n) {
double Ver_Hor_COST = 1;
if (n == null || closedSet[(int) n.getElement() - 1]
|| n.isVisited())
return;
boolean isOpen = openSet.contains(n);
if(!isOpen ) {
n.setgValue(current.getgValue() + Ver_Hor_COST);
n.setfValue(n.getgValue() + n.gethValue());
openSet.add(n);
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/Graph.java | package AGraphSearch;
import java.util.*;
public class Graph {
// Attributes
private List<Node> allNodes;
// Methods
public Graph() {
this.allNodes = new ArrayList<>();
}
public void setAllNodes(List<Node> allNodes) {
this.allNodes = allNodes;
}
public List<Node> getAllNodes(){
return this.allNodes;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/a-graph-search/java/SolveMaze.java | package AGraphSearch;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
public class SolveMaze {
public static void main(String[] args) {
// Draw the maze
JFrame f = new JFrame("Maze");
f.setSize(1000, 1000);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Maze maze = new Maze();
f.add(maze);
f.setVisible(true);
Graph g = maze.getGraph();
List<Node> nodeVisited = new ArrayList<>();
// New
JFrame f3 = new JFrame("Heuristic heatmap");
f3.setSize(1000, 1000);
f3.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
DrawHeuristic d = new DrawHeuristic(maze);
f3.add(d);
f3.setVisible(true);
AStar aStatSearchEngine = new AStar();
nodeVisited = aStatSearchEngine.search(g,
maze.getStartingPoint(), maze.getTargetPoint());
//for (Node n : nodeVisited) {
// System.out.println("Node" +n.getElement().toString());
//}
System.out.println("A* Search is done!");
FinalPath finalPath = new FinalPath(maze,nodeVisited);
JFrame f4 = new JFrame("A*");
f4.setSize(1000, 1000);
f4.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f4.add(finalPath);
f4.setVisible(true);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/greedy-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/greedy-search/java/ActivitySelection.java | class ActivitySelection {
// Prints a maximum set of activities that can be done
// by a single person, one at a time.
public static void printMaxActivities(int s[], int f[], int n) {
int i, j;
System.out.println("Following activities are selected");
// The first activity always gets selected
i = 0;
System.out.print(i + " ");
// Consider rest of the activities
for (j = 1; j < n; j++) {
// If this activity has start time greater than
// or equal to the finish time of previously
// selected activity, then select it
if (s[j] >= f[i]) {
System.out.print(j + " ");
i = j;
}
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/greedy-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/greedy-search/java/Main.java | // Activity Selection Problem.
// The following implementation assumes that the activities
// are already sorted according to their finish time
// More on Greedy ALgorithms
// https://www.geeksforgeeks.org/greedy-algorithms/#standardgreedy
import java.io.*;
import java.lang.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
int s[] = {1, 3, 0, 5, 8, 5};
int f[] = {2, 4, 6, 7, 9, 9};
int n = s.length;
// Function call
ActivitySelection.printMaxActivities(s, f, n);
}
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/greedy-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/informed-search/greedy-search/python/greedy_search.py |
# Python3 program for activity selection problem.
# The following implementation assumes that the activities
# are already sorted according to their finish time
def print_max_activities(s, f):
"""Prints a maximum set of activities that can be done by a single person, one at a time
"""
n = len(f)
print("Following activities are selected")
# The first activity is always selected
i = 0
print(i, end=' ')
# Consider rest of the activities
for j in range(1, n):
# If this activity has start time greater than
# or equal to the finish time of previously
# selected activity, then select it
if s[j] >= f[i]:
print(j, end=' ')
i = j
# Driver code
if __name__ == '__main__':
s = [1, 3, 0, 5, 8, 5]
f = [2, 4, 6, 7, 9, 9]
# Function call
print_max_activities(s, f)
# This code is contributed by Nikhil Kumar Singh |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/linear-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/linear-search/python/linear_search.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""linear_search.py
A program to demonstrate linear searching.
"""
# Searching an element in a list/array in python
# can be simply done using \'in\' operator
# Example:
# if x in arr:
# print arr.index(x)
# If you want to implement Linear Search in python
# Linearly search x in arr[]
# If x is present then return its location
# else return -1
def main():
"""main program"""
arr = [4,8,2,6,9,0,3]
linear_search(arr, 4)
def linear_search(arr, x):
"""linear search"""
for i in range(len(arr)):
if arr[i] == x:
return i
return -1
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/boyer-moore | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/boyer-moore/python/boyer_moore.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""boyer_moore.py
The Boyer-Moore algorithm is a powerful string searching algorithm known for its efficiency in practice. Here's how the algorithm works:
Preprocessing: Before searching, we preprocess the pattern to create a "last occurrence" table, which stores the rightmost occurrence of each character in the pattern.
Searching: We start searching the text from the end of the pattern towards the beginning. At each step, we compare characters from right to left:
If there is a match, we continue comparing characters until the entire pattern matches the corresponding substring in the text.
If there is a mismatch, we use the information from the last occurrence table to determine how far we can shift the pattern.
Termination: We continue this process until we reach the end of the text or find all occurrences of the pattern.
In the example usage, we demonstrate how to search for occurrences of a pattern "AABA" in a text "AABAACAADAABAAABAA" using the Boyer-Moore algorithm. We call the boyer_moore_search function to obtain a list of indices where the pattern starts in the text. Adjustments to the text and pattern can be made based on the specific problem being solved.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from sys import maxsize
from itertools import permutations
from typing import List
V = 4
def main() -> None:
"""Driving code and main function"""
# Example: Search for occurrences of a pattern in a text
text = "AABAACAADAABAAABAA"
pattern = "AABA"
occurrences = boyer_moore_search(text, pattern)
print("Occurrences of the pattern:", occurrences)
return None
def boyer_moore_search(text: str, pattern: str) -> List[int]:
"""Search for all occurrences of a pattern in a text using the Boyer-Moore algorithm.
Args:
text (str): The text to search in.
pattern (str): The pattern to search for.
Returns:
List[int]: A list of indices where the pattern starts in the text.
"""
if not text or not pattern:
return []
n, m = len(text), len(pattern)
if m > n:
return []
last_occurrence = {char: i for i, char in enumerate(pattern)}
occurrences = []
i = m - 1 # Start at the end of the pattern
j = m - 1 # Match characters from right to left
while i < n:
if text[i] == pattern[j]:
if j == 0:
occurrences.append(i)
i += m * 2 - 1 # Skip the rest of the block where the pattern occurs
else:
i -= 1
j -= 1
else:
if text[i] in last_occurrence:
i += m - min(j, 1 + last_occurrence[text[i]])
else:
i += m
j = m - 1
return occurrences
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/knutt-morris-pratt | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/knutt-morris-pratt/python/knutt_morris_pratt.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""knutt_morris_pratt.py
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from sys import maxsize
from itertools import permutations
from typing import List
def main() -> None:
"""Driving code and main function"""
# Example: Search for occurrences of a pattern in a text
text = "AABAACAADAABAAABAA"
pattern = "AABA"
occurrences = kmp_search(text, pattern)
print("Occurrences of the pattern:", occurrences)
return None
def kmp_search(text: str, pattern: str) -> List[int]:
"""Search for all occurrences of a pattern in a text using the Knuth-Morris-Pratt algorithm.
Args:
text (str): The text to search in.
pattern (str): The pattern to search for.
Returns:
List[int]: A list of indices where the pattern starts in the text.
"""
if not text or not pattern:
return []
n, m = len(text), len(pattern)
if m > n:
return []
# Compute the prefix function for the pattern
prefix = compute_prefix_function(pattern)
occurrences = []
j = 0 # Index into the text
k = 0 # Length of the longest prefix of pattern[:j] that is also a suffix of pattern[:j]
while j < n:
if text[j] == pattern[k]:
j += 1
k += 1
if k == m:
occurrences.append(j - m)
k = prefix[k - 1]
else:
k = prefix[k - 1] if k > 0 else 0
if k == 0:
j += 1
return occurrences
def compute_prefix_function(pattern: str) -> List[int]:
"""Compute the prefix function for a given pattern.
Args:
pattern (str): The pattern.
Returns:
List[int]: The prefix function for the pattern.
"""
m = len(pattern)
prefix = [0] * m
k = 0
for q in range(1, m):
while k > 0 and pattern[k] != pattern[q]:
k = prefix[k - 1]
if pattern[k] == pattern[q]:
k += 1
prefix[q] = k
return prefix
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/rabin-karp | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/rabin-karp/python/rabin_karp.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""rabin_karp.py
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from sys import maxsize
from itertools import permutations
from typing import List
def main() -> None:
"""Driving code and main function"""
# Example: Search for occurrences of a pattern in a text
text = "AABAACAADAABAAABAA"
pattern = "AABA"
occurrences = rabin_karp_search(text, pattern)
print("Occurrences of the pattern:", occurrences)
return None
def rabin_karp_search(text: str, pattern: str) -> List[int]:
"""Search for all occurrences of a pattern in a text using the Rabin-Karp algorithm.
Args:
text (str): The text to search in.
pattern (str): The pattern to search for.
Returns:
List[int]: A list of indices where the pattern starts in the text.
"""
if not text or not pattern:
return []
n, m = len(text), len(pattern)
if m > n:
return []
# Calculate the hash value of the pattern and the first window of the text
pattern_hash = hash(pattern)
text_hash = hash(text[:m])
occurrences = []
for i in range(n - m + 1):
if text_hash == pattern_hash and text[i:i+m] == pattern:
occurrences.append(i)
if i < n - m:
# Update the hash value for the next window
text_hash = (text_hash - ord(text[i])) + ord(text[i+m])
return occurrences
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/binary-search | repos/exploratory-tech-studio/tech-studio-projects/algorithms/searching/binary-search/python/binary_search.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""binary_search.py
A program to demonstrate recursive binary searching.
"""
def main():
arr = [2, 3, 4, 10, 40]
x = 10
binary_search([0,1,2,3,4,5,6,7,8,9,8,9,9],2,7,4)
result = binary_search(arr, 0, len(arr) - 1, x)
if result != -1:
print("Element", x, "is present at index", result)
else:
print("Element", x, "is not present in the array")
def binary_search(arr, low, high, x):
"""Binary search
"""
# Check base case
if high >= low:
mid = (high + low) // 2
# If element is present at the middle itself
if arr[mid] == x:
return mid
# If element is smaller than mid, then it can only
# be present in left subarray
elif arr[mid] > x:
return binary_search(arr, low, mid - 1, x)
# Else the element can only be present in right subarray
else:
return binary_search(arr, mid + 1, high, x)
else:
# Element is not present in the array
return -1
if __name__ == "__main__":
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/least-squares-method | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/least-squares-method/python/less_squares_method.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""travelling_salesman_problem.py
The program implements a solution to the Traveling Salesman Problem (TSP), a classic problem
in graph theory and combinatorial optimization. The goal of the TSP is to find the shortest
possible route that visits every city exactly once and returns to the original city. In this
program, cities are repressented as vertices of a graph, and the distances between them are
represented by edge weights in the graph.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import numpy as np
from typing import Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Linear regression using the Least Squares Method
X = np.array([[1, 2], [1, 3], [1, 4], [1, 5]])
y = np.array([2, 3, 4, 5])
coefficients = least_squares_method(X, y)
print("Coefficients:", coefficients)
return None
def least_squares_method(X: np.ndarray, y: np.ndarray) -> np.ndarray:
"""Solve a linear regression problem using the Least Squares Method.
Args:
X (np.ndarray): Matrix of independent variables (features).
y (np.ndarray): Vector of dependent variable (target).
Returns:
np.ndarray: Vector of coefficients (parameters).
"""
X_transpose = np.transpose(X)
coefficients = np.dot(np.linalg.inv(np.dot(X_transpose, X)), np.dot(X_transpose, y))
return coefficients
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/gaussian-elimination | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/gaussian-elimination/python/gaussian_elimination.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""gaussian_elimination.py
The Gaussian Elimination algorithm is used to solve a system of linear equations of the form Ax = b, where A is the coefficient matrix, x is the solution vector, and b is the right-hand side vector.
Partial Pivoting: During each iteration of the forward elimination phase, the algorithm performs partial pivoting to ensure numerical stability. It swaps rows to move the largest absolute value in the current column to the diagonal position.
Forward Elimination: The algorithm performs row operations to eliminate coefficients below the diagonal, making the coefficient matrix upper triangular.
Back Substitution: Once the coefficient matrix is in upper triangular form, the algorithm performs back substitution to solve for the solution vector x.
Example Usage: In the if __name__ == "__main__": block, an example usage of the gaussian_elimination function is provided. We define a coefficient matrix A and a right-hand side vector b, and then call the gaussian_elimination function to find the solution vector x. Finally, we print the solution.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import numpy as np
from typing import Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Solve a system of linear equations
A = np.array([[2, 1, -1], [-3, -1, 2], [-2, 1, 2]])
b = np.array([8, -11, -3])
solution = gaussian_elimination(A, b)
print("Solution:", solution)
return None
def gaussian_elimination(A: np.ndarray, b: np.ndarray) -> np.ndarray:
"""Solve a system of linear equations using Gaussian Elimination.
Args:
A (np.ndarray): Coefficient matrix.
b (np.ndarray): Right-hand side vector.
Returns:
np.ndarray: Solution vector.
"""
n = len(b)
augmented_matrix = np.hstack((A, b.reshape(-1, 1)))
for i in range(n):
# Partial pivoting
maximum_index = np.argmax(abs(augmented_matrix[i:, i])) + i
if maximum_index != i:
augmented_matrix[[i, maximum_index]] = augmented_matrix[[maximum_index, i]]
# Forward elimination
pivot = augmented_matrix[i, i]
augmented_matrix[i] /= pivot
for j in range(i+1, n):
factor = augmented_matrix[j, i]
augmented_matrix[j] -= factor * augmented_matrix[i]
# Back substitution
x = np.zeros(n)
for i in range(n-1, -1, -1):
x[i] = augmented_matrix[i, -1]
for j in range(i+1, n):
x[i] -= augmented_matrix[i, j] * x[j]
return x
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/jacobi-iteration | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/jacobi-iteration/python/jacobi_iteration.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""jacobi_iteration.py
The Jacobi Iteration method is an iterative numerical technique used to solve a system of linear equations of the form Ax = b, where A is the coefficient matrix, x is the solution vector, and b is the right-hand side vector.
Jacobi Iteration: In each iteration, the method updates the solution vector x using the formula x_new = D^(-1)(b - Rx), where D is the diagonal matrix of A, and R is the remainder matrix obtained by subtracting D from A.
Convergence Criteria: The iteration continues until a specified maximum number of iterations is reached or until the change in the solution vector x falls below a given tolerance value.
Example Usage: In the if __name__ == "__main__": block, an example usage of the jacobi_iteration function is provided. We define a coefficient matrix A, a right-hand side vector b, and specify the maximum number of iterations. We then call the jacobi_iteration function to find the solution vector x. Finally, we print the solution.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import numpy as np
from typing import Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Solve a system of linear equations
A = np.array([[2, -1, 0], [-1, 2, -1], [0, -1, 2]])
b = np.array([1, 0, 1])
max_iterations = 100
solution = jacobi_iteration(A, b, max_iterations)
print("Solution:", solution)
return None
"""Solve a system of linear equations using the Jacobi Iteration method.
Args:
A (np.ndarray): Coefficient matrix.
b (np.ndarray): Right-hand side vector.
max_iterations (int): Maximum number of iterations.
tolerance (float, optional): Tolerance for convergence. Defaults to 1e-10.
Returns:
np.ndarray: Solution vector.
"""
n = len(b)
x = np.zeros(n)
D = np.diag(np.diag(A))
R = A - D
for _ in range(max_iterations):
x_new = np.dot(np.linalg.inv(D), b - np.dot(R, x))
if np.linalg.norm(x_new - x) < tolerance:
return x_new
x = x_new
return x
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/eigenvalue-algorithms/power-iteration | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/eigenvalue-algorithms/power-iteration/python/power_iteration.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""power_iteration.py
The Power Iteration Algorithm is an iterative method used to find the dominant eigenvalue (the eigenvalue with the largest magnitude) and its corresponding eigenvector of a square matrix. It is a simple and efficient method for computing these eigenpairs.
Initialization: We start with an initial guess for the eigenvector v, typically a random vector. We normalize this vector to have unit length.
Iterations: During each iteration, we multiply the matrix A by the current eigenvector v to obtain a new vector. We then normalize this new vector to maintain unit length. This process is repeated for a specified number of iterations.
Convergence: As the number of iterations increases, the power iteration converges towards the dominant eigenpair of the matrix A. The dominant eigenvalue is given by the Rayleigh quotient eigenvalue = v^T A v, where v is the corresponding eigenvector.
Example Usage: In the if __name__ == "__main__": block, an example usage of the power_iteration function is provided. We define a matrix A and specify the number of iterations for the power iteration algorithm. We then call the power_iteration function to find the dominant eigenvalue and corresponding eigenvector of A. Finally, we print the results.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from sys import maxsize
from itertools import permutations
from typing import List
import numpy as np
def main() -> None:
"""Driving code and main function"""
# Example: Find the dominant eigenvalue and eigenvector of a matrix
A = np.array([[4, -2, 2], [-2, 2, -4], [2, -4, 11]])
num_iterations = 100
dominant_eigenvalue, corresponding_eigenvector = power_iteration(A, num_iterations)
print("Dominant eigenvalue:", dominant_eigenvalue)
print("Corresponding eigenvector:", corresponding_eigenvector)
return None
def power_iteration(A: np.ndarray, num_iterations: int) -> Tuple[float, np.ndarray]:
"""Approximate the dominant eigenvalue and corresponding eigenvector of a square matrix
using the Power Iteration Algorithm.
Args:
A (np.ndarray): Square matrix.
num_iterations (int): Number of iterations for power iteration.
Returns:
Tuple[float, np.ndarray]: A tuple containing the dominant eigenvalue and the corresponding eigenvector.
"""
n = A.shape[0]
v = np.random.rand(n)
v /= np.linalg.norm(v)
for _ in range(num_iterations):
v = np.dot(A, v)
v /= np.linalg.norm(v)
eigenvalue = np.dot(v, np.dot(A, v))
return eigenvalue, v
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/eigenvalue-algorithms/qr-algorithm | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/eigenvalue-algorithms/qr-algorithm/python/qr_algorithm.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""qr_algorithm.py
The QR Algorithm is an iterative method used to compute the eigenvalues and eigenvectors of a square matrix. It is based on the idea of decomposing the matrix A into the product of an orthogonal matrix Q and an upper triangular matrix R, such that A = QR.
Initialization: We start with an initial guess for the matrix A. In this implementation, we initialize the matrix Q as the identity matrix.
Iterations: During each iteration of the QR Algorithm, we decompose the matrix A into the product of Q and R using the QR decomposition. We then update the matrix A to be the product of R and Q, effectively shifting the matrix towards its upper Hessenberg form, which is diagonalizable.
Convergence: As the number of iterations increases, the matrix A converges to a triangular matrix with the eigenvalues along its diagonal. The columns of Q represent the corresponding eigenvectors of A.
Example Usage: In the if __name__ == "__main__": block, an example usage of the qr_algorithm function is provided. We define a matrix A and specify the number of iterations for the QR Algorithm. We then call the qr_algorithm function to find the eigenvalues and eigenvectors of A. Finally, we print the results.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import numpy as np
from typing import Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Find the eigenvalues and eigenvectors of a matrix
A = np.array([[4, -2, 2], [-2, 2, -4], [2, -4, 11]])
num_iterations = 100
eigenvalues, eigenvectors = qr_algorithm(A, num_iterations)
print("Eigenvalues:", eigenvalues)
print("Eigenvectors:", eigenvectors)
return None
def qr_algorithm(A: np.ndarray, num_iterations: int) -> Tuple[np.ndarray, np.ndarray]:
"""Approximate the eigenvalues and eigenvectors of a square matrix using the QR Algorithm.
Args:
A (np.ndarray): Square matrix.
num_iterations (int): Number of iterations for the QR Algorithm.
Returns:
Tuple[np.ndarray, np.ndarray]: A tuple containing the eigenvalues and eigenvectors.
"""
n = A.shape[0]
Q = np.eye(n)
for _ in range(num_iterations):
Q, R = np.linalg.qr(np.dot(A, Q))
A = np.dot(R, Q)
eigenvalues = np.diag(A)
eigenvectors = Q
return eigenvalues, eigenvectors
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/eigenvalue-algorithms/lanczos-algorithm | repos/exploratory-tech-studio/tech-studio-projects/algorithms/linear-algebra/eigenvalue-algorithms/lanczos-algorithm/python/lanczos_algorithm.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""lanczos_algorithm.py
The Lanczos Algorithm is an iterative method used to approximate the smallest eigenvalue and corresponding eigenvector of a real symmetric matrix. It is particularly useful for large sparse matrices, such as those encountered in quantum mechanics and numerical simulations.
Lanczos Iteration: The algorithm iteratively constructs an orthogonal basis for the Krylov subspace of the matrix A, spanned by the vectors v, Av, A^2v, ..., A^(k-1)v, where v is an initial vector.
Lanczos Triadiagonalization: During each iteration, the Lanczos algorithm computes a tridiagonal matrix T that represents the projection of A onto the Krylov subspace. This tridiagonal matrix is similar to A, and its eigenvalues are approximations of the eigenvalues of A.
Eigenvalue Estimation: After a fixed number of iterations (k), the Lanczos algorithm computes the eigenvalues and eigenvectors of the tridiagonal matrix T. The smallest eigenvalue of T corresponds to an approximation of the smallest eigenvalue of A, and its corresponding eigenvector approximates the corresponding eigenvector of A.
Example Usage: In the if __name__ == "__main__": block, an example usage of the lanczos_algorithm function is provided. We define a symmetric matrix A, an initial vector v, and the number of Lanczos iterations k. We then call the lanczos_algorithm function to find the smallest eigenvalue and corresponding eigenvector of A. Finally, we print the results.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from sys import maxsize
from itertools import permutations
from typing import List, Tuple
import numpy as np
from typing import Callable, Tuple
def main():
"""Driving code"""
# Example: Find the smallest eigenvalue and eigenvector of a symmetric matrix
A = np.array([[4, -2, 2], [-2, 2, -4], [2, -4, 11]])
v = np.array([1, 1, 1])
k = 10
smallest_eigenvalue, corresponding_eigenvector = lanczos_algorithm(A, v, k)
print("Smallest eigenvalue:", smallest_eigenvalue)
print("Corresponding eigenvector:", corresponding_eigenvector)
def lanczos_algorithm(A: np.ndarray, v: np.ndarray, k: int) -> Tuple[np.ndarray, np.ndarray]:
"""Approximate the smallest eigenvalue and corresponding eigenvector of a symmetric matrix
using the Lanczos Algorithm.
Args:
A (np.ndarray): Symmetric matrix.
v (np.ndarray): Initial vector for Lanczos iteration.
k (int): Number of Lanczos iterations.
Returns:
Tuple[np.ndarray, np.ndarray]: A tuple containing the smallest eigenvalue and the corresponding eigenvector.
"""
n = A.shape[0]
V = np.zeros((n, k+1))
T = np.zeros((k, k))
V[:, 0] = v / np.linalg.norm(v)
for i in range(k):
w = np.dot(A, V[:, i])
alpha = np.dot(w, V[:, i])
w -= alpha * V[:, i]
if i > 0:
w -= beta * V[:, i-1]
beta = np.linalg.norm(w)
V[:, i+1] = w / beta
T[i, i] = alpha
if i > 0:
T[i, i-1] = beta
T[i-1, i] = beta
eigenvalues, eigenvectors = np.linalg.eig(T)
smallest_eigenvalue = np.min(eigenvalues)
index = np.argmin(eigenvalues)
corresponding_eigenvector = eigenvectors[:, index]
return smallest_eigenvalue, corresponding_eigenvector
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/README.md | # Traveling Salesman Problem (TSP) Algorithm
This folder contains the code implementation and explanation for solving the Traveling Salesman Problem (TSP) using a backtracking approach.
## Description
The Traveling Salesman Problem (TSP) is a well-known optimization problem in computer science. It seeks to find the shortest possible route that visits each city in a given set exactly once and returns to the starting city. This problem has various applications in areas like logistics, route planning, and circuit design.
## Algorithm
This implementation utilizes a backtracking algorithm to explore different possible routes. It starts at the starting city and recursively explores neighboring unvisited cities. At each step, it checks if the current path leads to a promising solution (e.g., keeping track of the shortest distance found so far) and avoids revisiting cities or exceeding a distance limit. If a complete valid route (visiting all cities and returning to the start) is found with a shorter distance than previously encountered, it updates the best solution. Backtracking occurs when a path leads to a dead end (no valid next move).
Note: Backtracking can be computationally expensive for large datasets due to the exploration of a vast number of potential paths.
* **Time Complexity:** O(n^n) in the worst case, where n is the number of cities. This is because the algorithm explores all possible permutations of cities. However, in practice, the complexity can be lower depending on pruning techniques and early termination strategies.
* **Space Complexity:** O(n) due to the recursion stack used to keep track of the explored path.
## Applications
Combinatorial Optimization, Constraint Satisfaction Problems, Puzzle Solving, Graph Theory, Artificial Intelligence, Bioinformatics, Mathemtatical Problems, Robotics, Cryptography, Software Testing |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/java/TravellingSalesmanProblemSolver.java | import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class TravellingSalesmanProblemSolver {
public static int travellingSalesmanProblem(int[][] graph, int s) {
int V = graph.length; // Number of vertices
// Store all vertices apart from the source vertex
List<Integer> vertex = new ArrayList<>();
for (int i = 0; i < V; i++) {
if (i != s) {
vertex.add(i);
}
}
// Store minimum weight Hamiltonian Cycle
int minPath = Integer.MAX_VALUE;
// Get all permutations of remaining vertices
List<List<Integer>> permutations = permute(vertex);
for (List<Integer> perm : permutations) {
// Store current path weight (cost)
int currentPathWeight = 0;
// Compute current path weight
int k = s;
for (int j : perm) {
currentPathWeight += graph[k][j];
k = j;
}
currentPathWeight += graph[k][s];
// Update minimum path weight
minPath = Math.min(minPath, currentPathWeight);
}
return minPath;
}
// Helper method to generate all permutations of a list of integers
private static List<List<Integer>> permute(List<Integer> nums) {
List<List<Integer>> result = new ArrayList<>();
permuteHelper(nums, 0, result);
return result;
}
private static void permuteHelper(List<Integer> nums, int start, List<List<Integer>> result) {
if (start == nums.size() - 1) {
result.add(new ArrayList<>(nums));
return;
}
for (int i = start; i < nums.size(); i++) {
Collections.swap(nums, i, start);
permuteHelper(nums, start + 1, result);
Collections.swap(nums, i, start);
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/java/Main.java | import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// Number of vertices
int V = 4;
// Weighted graph represented as an adjacency matrix
int[][] graph = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
int initVertex = 0;
int minimumPath = TravellingSalesmanProblemSolver.travellingSalesmanProblem(graph, initVertex);
System.out.println("Minimum path weight is: " + minimumPath);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/cpp/TSMSolver.h | #ifndef MAZESOLVER_H
#define MAZESOLVER_H
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
using namespace std;
class TSMSolver {
public:
/**
* @brief Solves the Travelling Salesman Problem (TSP) using brute-force permutation.
*
* Given a weighted graph represented as an adjacency matrix, this method finds the minimum Hamiltonian cycle,
* i.e., a cycle that visits each vertex exactly once and returns to the starting vertex, with the
* minimum total weight.
*
* @param graph The weighted graph represented as an adjacency matrix.
* @param s The starting vertex for the salesman.
* @return The minimum path weight.
*/
int travellingSalesmanProblem(const std::vector<std::vector<int>>& graph, int s);
};
#endif // TSMSOLVER_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/cpp/TSMSolver.cpp | #include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <algorithm>
#include <limits>
#include "TSMSolver.h"
using namespace std;
int TSMSolver::travellingSalesmanProblem(const std::vector<std::vector<int>>& graph, int s) {
int V = graph.size(); // Number of vertices
// Store all vertices apart from the source vertex
std::vector<int> vertex(V);
for (int i = 0; i < V; i++) {
if (i != s) {
vertex.push_back(i);
}
}
// Store minimum weight Hamiltonian Cycle
int minPath = std::numeric_limits<int>::max();
// Get all permutations of remaining vertices
std::vector<std::vector<int>> permutations;
do {
// Store current path weight (cost)
int currentPathWeight = 0;
// Compute current path weight
int k = s;
for (int j : vertex) {
currentPathWeight += graph[k][j];
k = j;
}
currentPathWeight += graph[k][s];
// Update minimum path weight
minPath = std::min(minPath, currentPathWeight);
} while (std::next_permutation(vertex.begin(), vertex.end()));
return minPath;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/cpp/main.cpp | /*
Description:
------------
This program solves the Travelling Salesman Problem (TSP) using brute-force permutation.
Given a weighted graph represented as an adjacency matrix, it finds the minimum Hamiltonian cycle,
i.e., a cycle that visits each vertex exactly once and returns to the starting vertex, with the
minimum total weight.
Compile the program:
--------------------
Step 2: Compile each source file
g++ -c main.cpp -o main.o
g++ -c TSMSolver.cpp -o TSMSolver.o
Step 2: Link all object files together to create an executable
g++ main.o TSMSolver.o -o main
*/
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include "TSMSolver.h"
using namespace std;
int main() {
// Weighted graph represented as an adjacency matrix
vector<vector<int>> graph = {
{0, 10, 15, 20},
{10, 0, 35, 25},
{15, 35, 0, 30},
{20, 25, 30, 0}
};
int initVertex = 0; // Starting vertex for the salesman
TSMSolver solver;
int minimumPath = solver.travellingSalesmanProblem(graph, initVertex);
std::cout << "Minimum path weight is: " << minimumPath << std::endl;
return 0;
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/travelling-salesman-problem/python/travelling_salesman_problem.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""travelling_salesman_problem.py
The program implements a solution to the Traveling Salesman Problem (TSP), a classic problem
in graph theory and combinatorial optimization. The goal of the TSP is to find the shortest
possible route that visits every city exactly once and returns to the original city. In this
program, cities are represented as vertices of a graph, and the distances between them are
represented by edge weights in the graph.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
from typing import List
V = 4
def main() -> None:
"""Driving code and main function"""
graph = [
[0, 10, 15, 20],
[10, 0, 35, 25],
[15, 35, 0, 30],
[20, 25, 30, 0]
]
init_vertex = 0
minimum_path = travelling_salesman_problem(graph, init_vertex)
print(f"Minimum path weight is '{minimum_path}'")
return None
def travelling_salesman_problem(graph: List[List[int]], s: int) -> int:
"""This function takes two arguments: graph, which represents the weighted graph as an adjacency matrix,
and s, which is the starting vertex for the salesman. It computes the minimum Hamiltonian cycle (a
cycle that visits each vertex exactly once and returns to the starting vertex) in the given graph. The
function utilizes backtracking to explore all possible paths, calculating the total path weight for each
and pruning paths that exceed the current known minimum. It returns the minimum path weight, which represents
the shortest possible route for the salesman.
Keyword arguments:
graph (List[List[int]]) -- The adjacency matrix representing the weighted graph.
s (int) -- The starting vertex for the salesman.
"""
# Initialize visited array
visited = [False] * V
visited[s] = True
# Initialize the minimum path as a very large value
min_path = [float('inf')]
# Backtracking function to find the minimum path
def tsp_helper(curr_pos, count, cost):
if count == V and graph[curr_pos][s]:
min_path[0] = min(min_path[0], cost + graph[curr_pos][s])
return
for i in range(V):
if not visited[i] and graph[curr_pos][i]:
visited[i] = True
tsp_helper(i, count + 1, cost + graph[curr_pos][i])
visited[i] = False
# Start the recursion from the initial vertex
tsp_helper(s, 1, 0)
return min_path[0]
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/README.md | # Rat in a Maze Algorithm
This folder contains the code implementation and explanation for the Rat in a Maze problem algorithm.
## Description
The Rat in a Maze problem is a classic backtracking algorithm where you help a rat navigate from a starting point to an exit within a maze represented by a 2D grid. The rat can only move up, down, left, or right, and cannot visit walls or go outside the maze boundaries.
## Algorithm
This implementation utilizes a recursive backtracking approach to explore different paths within the maze. The algorithm checks if the current position is the exit, and if not, it explores valid neighboring cells (not walls or already visited). If a valid path leads to the exit, success is achieved. Otherwise, the algorithm backtracks and tries a different direction.
* **Time Complexity:** O(exp(m*n)) in the worst case, where m and n are the dimensions of the maze grid. This is due to the exponential nature of exploring all possible paths. However, in practice, the complexity can be lower depending on the maze structure.
* **Space Complexity:** O(m*n) due to the recursion stack space used to keep track of the explored path.
## Applications
Combinatorial Optimization, Constraint Satisfaction Problems, Puzzle Solving, Graph Theory, Artificial Intelligence, Bioinformatics, Mathemtatical Problems, Robotics, Cryptography, Software Testing |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/java/MazeSolver.java | import java.util.List;
public class MazeSolver {
// D -> Down, L -> Left, R -> Right, U -> Up
static final String DIRECTION = "DLRU";
// Arrays to represent change in rows and columns.
static final int[] dr = {1, 0, 0, -1};
static final int[] dc = {0, -1, 1, 0};
static boolean isValid(int row, int col, int n, int[][] maze) {
return row >= 0 && row < n && col >= 0 && col < n && maze[row][col] == 1;
}
static void findPath(int row, int col, int[][] maze, int n, List<String> result, StringBuilder currentPath) {
if (row == n - 1 && col == n - 1) {
result.add(currentPath.toString());
return;
}
maze[row][col] = 0;
for (int i = 0; i < 4; i++) {
int nextRow = row + dr[i];
int nextCol = col + dc[i];
if (isValid(nextRow, nextCol, n, maze)) {
currentPath.append(DIRECTION.charAt(i));
findPath(nextRow, nextCol, maze, n, result, currentPath);
currentPath.deleteCharAt(currentPath.length() - 1);
}
}
maze[row][col] = 1;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/java/Main.java | import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
int[][] maze = {
{1, 0, 0, 0},
{1, 1, 0, 1},
{1, 1, 0, 0},
{0, 1, 1, 1}
};
int n = maze.length;
List<String> result = new ArrayList<>();
StringBuilder currentPath = new StringBuilder();
if (maze[0][0] != 0 && maze[n - 1][n - 1] != 0) {
MazeSolver.findPath(0, 0, maze, n, result, currentPath);
}
if (result.isEmpty()) {
System.out.println(-1);
} else {
System.out.println(String.join(" ", result));
}
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/cpp/MazeSolver.cpp | #include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include "MazeSolver.h"
using namespace std;
bool MazeSolver::isValid(int row, int col, int n, const vector<vector<int>>& maze) {
return row >= 0 && row < n && col >= 0 && col < n && maze[row][col] == 1;
}
void MazeSolver::findPath(int row, int col, vector<vector<int>>& maze, int n, vector<string>& result, string& currentPath) {
if (row == n - 1 && col == n - 1) {
result.push_back(currentPath);
return;
}
maze[row][col] = 0;
for (int i = 0; i < 4; i++) {
int nextRow = row + dr[i];
int nextCol = col + dc[i];
if (isValid(nextRow, nextCol, n, maze)) {
currentPath.push_back(DIRECTION[i]);
findPath(nextRow, nextCol, maze, n, result, currentPath);
currentPath.pop_back();
}
}
maze[row][col] = 1;
}
vector<string> MazeSolver::findAllPaths(vector<vector<int>>&maze) {
int n = maze.size();
vector<string> result;
string currentPath;
findPath(0, 0, maze, n, result, currentPath);
return result;
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/cpp/main.cpp | /*
Description:
------------
This program explores all possible paths in a maze using backtracking. It starts from the top-left corner
of the maze and recursively explores all valid paths until it reaches the bottom-right corner. The is_valid
function checks whether a given cell is inside the maze and unblocked. The find_path function recursively
explores all valid directions from the current cell and backtracks when necessary. Finally, the main function
initializes the maze and calls the find_path function to find all valid paths.
Compile the program:
--------------------
Step 1: Compile each .cpp file into object files
g++ -c main.cpp -o main.o
g++ -c MazeSolver.cpp -o MazeSolver.o
Step 2: Link all object files together to create an executable
g++ main.o MazeSolver.o -o main
*/
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include "MazeSolver.h"
using namespace std;
int main() {
vector<vector<int>> maze = {
{1, 0, 0, 0},
{1, 1, 0, 1},
{1, 1, 0, 0},
{0, 1, 1, 1}
};
MazeSolver solver; // Create an instance of MazeSolver
vector<string> result = solver.findAllPaths(maze); // Use the findAllPaths method
if (result.empty()) {
cout << -1 << endl;
}
else {
for (const string& path : result) {
cout << path << " ";
}
cout << endl;
}
return 0;
} |
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/cpp/MazeSolver.h | #ifndef MAZESOLVER_H
#define MAZESOLVER_H
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
using namespace std;
class MazeSolver {
private:
const std::string DIRECTION = "DLRU";
const std::vector<int> dr = { 1, 0, 0, -1 };
const std::vector<int> dc = { 0, -1, 1, 0 };
/**
* @brief Checks if a cell is valid in the maze.
*
* @param row The row index of the cell.
* @param col The column index of the cell.
* @param n The size of the maze.
* @param maze The maze represented as a 2D vector.
* @return true if the cell is valid (within bounds and not blocked), false otherwise.
*/
bool isValid(int row, int col, int n, const std::vector<std::vector<int>>& maze);
/**
* @brief Finds paths in the maze recursively.
*
* @param row The current row index.
* @param col The current column index.
* @param maze The maze represented as a 2D vector.
* @param n The size of the maze.
* @param result A vector to store the found paths.
* @param currentPath The current path being explored.
*/
void findPath(int row, int col, std::vector<std::vector<int>>& maze, int n, std::vector<std::string>& result, std::string& currentPath);
public:
/**
* @brief Finds all possible paths in the given maze.
*
* @param maze The maze represented as a 2D vector where 1 represents an open cell and 0 represents a blocked cell.
* @return A vector containing all possible paths from the starting cell to the destination cell.
*/
std::vector<std::string> findAllPaths(std::vector<std::vector<int>>& maze);
};
#endif // MAZESOLVER_H
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze | repos/exploratory-tech-studio/tech-studio-projects/algorithms/backtracking/rat-in-a-maze/python/rat_in_a_maze.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""rat_in_a_maze.py
This program explores all possible paths in a maze using backtracking. It starts from the top-left corner
of the maze and recursively explores all valid paths until it reaches the bottom-right corner. The is_valid
function checks whether a given cell is inside the maze and unblocked. The find_path function recursively
explores all valid directions from the current cell and backtracks when necessary. Finally, the main function
initializes the maze and calls the find_path function to find all valid paths.
.. _PEP 484:
https://www.python.org/dev/peps/pep-0484/
"""
from typing import List
# D -> Down
# L -> Left
# R -> Right
# U -> Up
DIRECTION = "DLRU"
# arrays to represent change in rows and columns
dr: list = [1, 0, 0, -1]
dc: list = [0, -1, 1, 0]
def main() -> None:
"Driver code and program entry point."
maze: List[list] = [
[1, 0, 0, 0],
[1, 1, 0, 1],
[1, 1, 0, 0],
[0, 1, 1, 1]
]
# get the length of the maze
n: int = len(maze)
# list to store all valid paths
result: list = []
# Store current path
current_path = ""
if maze[0][0] != 0 and maze[n - 1][n - 1] != 0:
# Function call to get all valid paths
find_path(0, 0, maze, n, result, current_path)
if not result:
print(-1)
else:
print(" ".join(result))
return None
def is_valid(row: int, col: int, n: int, maze: List[List[int]]) -> bool:
"""Check if cell(row, col) is inside the maze and unblocked.
Keyword arguments:
row (int) -- The row index of the cell.
col (int) -- The column index of the cell.
n (int) -- The size of the maze (number of rows/columns).
maze (List[List[int]]) -- The maze represented as a 2D array.
"""
return 0 <= row < n and 0 <= col < n and maze[row][col] == 1
def find_path(row, col, maze, n, ans, current_path) -> None:
"""Get all valid paths to escape the maze using backtracking.
Keyword arguments:
row (int) -- The current row index.
col (int) -- The current column index.
maze (List[List[int]]) -- The maze represented as a 2D array.
n (int) -- The size of the maze (number of rows/columns).
ans (List[str]) -- A list to store all valid paths.
current_path (str) -- The current path being explored.
"""
# if bottom right cell is reached, add current path to ans and return
if row == n - 1 and col == n - 1:
ans.append(current_path)
return
# mark current cell as blocked
maze[row][col] = 0
for i in range(4):
# find the next row based on the current row (row)
next_row = row + dr[i]
# find the next column based on the current column (col) and the dc[] array
next_col = col + dc[i]
# check if the next cell is valid or not
if is_valid(next_row, next_col, n, maze):
current_path += DIRECTION[i]
# recursively call the find_path function for
# the next cell
find_path(next_row, next_col, maze, n, ans, current_path)
# remove the last direction when backtracking
current_path = current_path[:-1]
# mark the current cell as unblocked
maze[row][col] = 1
return None
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/classical-genetic-algorithms | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/classical-genetic-algorithms/java/ClassicalGeneticAlgorithm.java | import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class ClassicalGeneticAlgorithm {
/**
* Main method to drive the genetic algorithm.
*/
public static void main(String[] args) {
// Example: Evolution towards a target binary sequence
List<Integer> targetSequence = List.of(1, 0, 1, 1, 0, 1, 0, 1); // Define the target sequence
int numGenerations = 100; // Number of generations
int populationSize = 100; // Size of the population
int chromosomeLength = targetSequence.size(); // Length of each chromosome
double mutationRate = 0.01; // Probability of mutation for each bit
List<Integer> fittestChromosome = geneticAlgorithm(targetSequence, chromosomeLength, populationSize, numGenerations, mutationRate);
System.out.println("Fittest chromosome: " + fittestChromosome);
}
/**
* Generate an initial population of binary chromosomes.
*
* @param populationSize Number of individuals in the population.
* @param chromosomeLength Length of each chromosome.
* @return Initial population represented as a list of binary chromosomes.
*/
public static List<List<Integer>> generatePopulation(int populationSize, int chromosomeLength) {
List<List<Integer>> population = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < populationSize; i++) {
List<Integer> chromosome = new ArrayList<>();
for (int j = 0; j < chromosomeLength; j++) {
chromosome.add(random.nextInt(2));
}
population.add(chromosome);
}
return population;
}
/**
* Compute the fitness value of a chromosome.
*
* @param chromosome Binary chromosome to evaluate.
* @param target Target binary sequence.
* @return Fitness value of the chromosome (number of matching bits with the target).
*/
public static int fitnessFunction(List<Integer> chromosome, List<Integer> target) {
int fitness = 0;
for (int i = 0; i < chromosome.size(); i++) {
if (chromosome.get(i).equals(target.get(i))) {
fitness++;
}
}
return fitness;
}
/**
* Perform selection of parents based on fitness.
*
* @param population Current population.
* @param target Target binary sequence.
* @param numParents Number of parents to select.
* @return Selected parent chromosomes.
*/
public static List<List<Integer>> selection(List<List<Integer>> population, List<Integer> target, int numParents) {
population.sort((a, b) -> fitnessFunction(b, target) - fitnessFunction(a, target));
return population.subList(0, numParents);
}
/**
* Perform crossover to produce offspring.
*
* @param parents Selected parent chromosomes.
* @param numOffspring Number of offspring to generate.
* @return Offspring chromosomes resulting from crossover.
*/
public static List<List<Integer>> crossover(List<List<Integer>> parents, int numOffspring) {
List<List<Integer>> offspring = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < numOffspring; i++) {
List<Integer> parent1 = parents.get(random.nextInt(parents.size()));
List<Integer> parent2 = parents.get(random.nextInt(parents.size()));
int crossoverPoint = random.nextInt(parent1.size());
List<Integer> child = new ArrayList<>(parent1.subList(0, crossoverPoint));
child.addAll(parent2.subList(crossoverPoint, parent2.size()));
offspring.add(child);
}
return offspring;
}
/**
* Perform mutation on offspring.
*
* @param offspring Offspring chromosomes.
* @param mutationRate Probability of mutation for each bit.
* @return Mutated offspring chromosomes.
*/
public static List<List<Integer>> mutation(List<List<Integer>> offspring, double mutationRate) {
Random random = new Random();
for (List<Integer> chromosome : offspring) {
for (int i = 0; i < chromosome.size(); i++) {
if (random.nextDouble() < mutationRate) {
chromosome.set(i, 1 - chromosome.get(i)); // Flip the bit
}
}
}
return offspring;
}
/**
* Perform a classical genetic algorithm to evolve towards a target binary sequence.
*
* @param target Target binary sequence to evolve towards.
* @param chromosomeLength Length of each chromosome.
* @param populationSize Number of individuals in the population.
* @param numGenerations Number of generations to run the algorithm.
* @param mutationRate Probability of mutation for each bit.
* @return The fittest chromosome found after the specified number of generations.
*/
public static List<Integer> geneticAlgorithm(List<Integer> target, int chromosomeLength, int populationSize, int numGenerations, double mutationRate) {
List<List<Integer>> population = generatePopulation(populationSize, chromosomeLength);
for (int generation = 0; generation < numGenerations; generation++) {
List<List<Integer>> parents = selection(population, target, populationSize / 2);
List<List<Integer>> offspring = crossover(parents, populationSize - parents.size());
offspring = mutation(offspring, mutationRate);
population = new ArrayList<>(parents);
population.addAll(offspring);
}
List<Integer> fittestChromosome = null;
int maxFitness = Integer.MIN_VALUE;
for (List<Integer> chromosome : population) {
int fitness = fitnessFunction(chromosome, target);
if (fitness > maxFitness) {
maxFitness = fitness;
fittestChromosome = chromosome;
}
}
return fittestChromosome;
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/classical-genetic-algorithms | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/classical-genetic-algorithms/python/classical_genetic_algorithm.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""classical_genetic_algorithm.py
The classical genetic algorithm mimics the process of natural selection and evolution to find the optimal solution to a given problem. Here's how the algorithm works:
Initialization: Generate an initial population of binary chromosomes randomly.
Fitness Function: Define a fitness function that evaluates how well each chromosome solves the problem. In this example, the fitness function computes the number of matching bits with the target binary sequence.
Selection: Select the fittest individuals (parents) from the population based on their fitness values.
Crossover: Produce offspring through crossover of selected parents. This creates new solutions by combining the genetic material of the parents.
Mutation: Introduce random changes (mutations) to the offspring chromosomes to maintain genetic diversity in the population.
Evolution: Repeat the selection, crossover, and mutation steps for a fixed number of generations.
Termination: After a certain number of generations, return the fittest chromosome found in the final population.
The example usage in the if __name__ == "__main__": block demonstrates how to use the genetic algorithm to evolve towards a target binary sequence. Adjustments to parameters such as the target sequence, number of generations, population size, and mutation rate can be made based on the specific problem being solved.
.. _PEP 0000:
https://peps.python.org/pep-0000/
"""
import random
from typing import List, Callable, Tuple
def main() -> None:
"""Driving code and main function"""
# Example: Evolution towards a target binary sequence
target_sequence = [1, 0, 1, 1, 0, 1, 0, 1] # Define the target sequence
num_generations = 100 # Number of generations
population_size = 100 # Size of the population
chromosome_length = len(target_sequence) # Length of each chromosome
mutation_rate = 0.01 # Probability of mutation for each bit
fittest_chromosome = genetic_algorithm(target_sequence, chromosome_length, population_size, num_generations, mutation_rate)
print("Fittest chromosome:", fittest_chromosome)
return None
def generate_population(population_size: int, chromosome_length: int) -> List[List[int]]:
"""Generate an initial population of binary chromosomes.
Args:
population_size (int): Number of individuals in the population.
chromosome_length (int): Length of each chromosome.
Returns:
List[List[int]]: Initial population represented as a list of binary chromosomes.
"""
return [[random.randint(0, 1) for _ in range(chromosome_length)] for _ in range(population_size)]
def fitness_function(chromosome: List[int], target: List[int]) -> int:
"""Compute the fitness value of a chromosome.
Args:
chromosome (List[int]): Binary chromosome to evaluate.
target (List[int]): Target binary sequence.
Returns:
int: Fitness value of the chromosome (number of matching bits with the target).
"""
return sum(c == t for c, t in zip(chromosome, target))
def selection(population: List[List[int]], fitness_fn: Callable[[List[int]], int], target: List[int], num_parents: int) -> List[List[int]]:
"""Perform selection of parents based on fitness.
Args:
population (List[List[int]]): Current population.
fitness_fn (Callable[[List[int]], int]): Fitness function.
target (List[int]): Target binary sequence.
num_parents (int): Number of parents to select.
Returns:
List[List[int]]: Selected parent chromosomes.
"""
return sorted(population, key=lambda x: fitness_fn(x, target), reverse=True)[:num_parents]
def crossover(parents: List[List[int]], num_offspring: int) -> List[List[int]]:
"""Perform crossover to produce offspring.
Args:
parents (List[List[int]]): Selected parent chromosomes.
num_offspring (int): Number of offspring to generate.
Returns:
List[List[int]]: Offspring chromosomes resulting from crossover.
"""
offspring = []
for _ in range(num_offspring):
parent1, parent2 = random.sample(parents, 2)
crossover_point = random.randint(1, len(parent1) - 1)
child = parent1[:crossover_point] + parent2[crossover_point:]
offspring.append(child)
return offspring
def mutation(offspring: List[List[int]], mutation_rate: float) -> List[List[int]]:
"""Perform mutation on offspring.
Args:
offspring (List[List[int]]): Offspring chromosomes.
mutation_rate (float): Probability of mutation for each bit.
Returns:
List[List[int]]: Mutated offspring chromosomes.
"""
for i in range(len(offspring)):
for j in range(len(offspring[i])):
if random.random() < mutation_rate:
offspring[i][j] = 1 - offspring[i][j] # Flip the bit
return offspring
def genetic_algorithm(target: List[int], chromosome_length: int, population_size: int, num_generations: int, mutation_rate: float) -> List[int]:
"""Perform a classical genetic algorithm to evolve towards a target binary sequence.
Args:
target (List[int]): Target binary sequence to evolve towards.
chromosome_length (int): Length of each chromosome.
population_size (int): Number of individuals in the population.
num_generations (int): Number of generations to run the algorithm.
mutation_rate (float): Probability of mutation for each bit.
Returns:
List[int]: The fittest chromosome found after the specified number of generations.
"""
population = generate_population(population_size, chromosome_length)
for _ in range(num_generations):
parents = selection(population, fitness_function, target, population_size // 2)
offspring = crossover(parents, population_size - len(parents))
offspring = mutation(offspring, mutation_rate)
population = parents + offspring
return max(population, key=lambda x: fitness_function(x, target))
if __name__ == '__main__':
main()
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/conjugate-gradient | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/conjugate-gradient/java/ConjugateGradient.java | import java.util.Arrays;
public class ConjugateGradient {
/**
* Solves a linear system Ax = b using the Conjugate Gradient method.
*
* @param A Coefficient matrix.
* @param b Right-hand side vector.
* @param x0 Initial guess for the solution.
* @param tol Tolerance for convergence.
* @param maxIter Maximum number of iterations.
* @return The solution vector and number of iterations as a tuple.
*/
public static Object[] conjugateGradient(double[][] A, double[] b, double[] x0, double tol, int maxIter) {
double[] x = Arrays.copyOf(x0, x0.length);
double[] r = Arrays.copyOf(b, b.length);
double[] p = Arrays.copyOf(r, r.length);
double rsold = dotProduct(r, r);
for (int i = 0; i < maxIter; i++) {
double[] Ap = matrixVectorProduct(A, p);
double alpha = rsold / dotProduct(p, Ap);
for (int j = 0; j < x.length; j++) {
x[j] += alpha * p[j];
r[j] -= alpha * Ap[j];
}
double rsnew = dotProduct(r, r);
if (Math.sqrt(rsnew) < tol) {
return new Object[]{x, i + 1};
}
double beta = rsnew / rsold;
for (int j = 0; j < p.length; j++) {
p[j] = r[j] + beta * p[j];
}
rsold = rsnew;
}
return new Object[]{x, maxIter};
}
/**
* Computes the dot product of two vectors.
*
* @param a Vector a.
* @param b Vector b.
* @return The dot product of vectors a and b.
*/
public static double dotProduct(double[] a, double[] b) {
double result = 0.0;
for (int i = 0; i < a.length; i++) {
result += a[i] * b[i];
}
return result;
}
/**
* Computes the matrix-vector product.
*
* @param A Matrix A.
* @param x Vector x.
* @return The result of the matrix-vector product Ax.
*/
public static double[] matrixVectorProduct(double[][] A, double[] x) {
int m = A.length;
int n = A[0].length;
double[] result = new double[m];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
result[i] += A[i][j] * x[j];
}
}
return result;
}
public static void main(String[] args) {
// Example: Solve a linear system using Conjugate Gradient method
double[][] A = {{4, 1}, {1, 3}};
double[] b = {1, 2};
double[] x0 = {0, 0};
double tol = 1e-6;
int maxIter = 1000;
Object[] result = conjugateGradient(A, b, x0, tol, maxIter);
double[] solution = (double[]) result[0];
int iterations = (int) result[1];
System.out.println("Solution: " + Arrays.toString(solution));
System.out.println("Number of iterations: " + iterations);
}
}
|
0 | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/conjugate-gradient | repos/exploratory-tech-studio/tech-studio-projects/algorithms/numerical-optimization-algorithms/conjugate-gradient/cpp/main.cpp | #include <iostream>
#include <vector>
#include <algorithm>
#include <random>
using namespace std;
// Define a chromosome as a vector of integers representing binary digits
using Chromosome = vector<int>;
// Function prototypes
vector<Chromosome> generatePopulation(int populationSize, int chromosomeLength);
int fitnessFunction(const Chromosome& chromosome, const Chromosome& target);
vector<Chromosome> selection(const vector<Chromosome>& population, const Chromosome& target, int numParents);
vector<Chromosome> crossover(const vector<Chromosome>& parents, int numOffspring);
vector<Chromosome> mutation(vector<Chromosome>& offspring, double mutationRate);
Chromosome geneticAlgorithm(const Chromosome& target, int chromosomeLength, int populationSize, int numGenerations, double mutationRate);
int main() {
// Example: Evolution towards a target binary sequence
Chromosome targetSequence = {1, 0, 1, 1, 0, 1, 0, 1}; // Define the target sequence
int numGenerations = 100; // Number of generations
int populationSize = 100; // Size of the population
int chromosomeLength = targetSequence.size(); // Length of each chromosome
double mutationRate = 0.01; // Probability of mutation for each bit
Chromosome fittestChromosome = geneticAlgorithm(targetSequence, chromosomeLength, populationSize, numGenerations, mutationRate);
cout << "Fittest chromosome: ";
for (int bit : fittestChromosome) {
cout << bit;
}
cout << endl;
return 0;
}
// Generate an initial population of binary chromosomes
vector<Chromosome> generatePopulation(int populationSize, int chromosomeLength) {
vector<Chromosome> population(populationSize, Chromosome(chromosomeLength));
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dis(0, 1);
for (auto& chromosome : population) {
for (int& bit : chromosome) {
bit = dis(gen);
}
}
return population;
}
// Compute the fitness value of a chromosome
int fitnessFunction(const Chromosome& chromosome, const Chromosome& target) {
int fitness = 0;
for (size_t i = 0; i < chromosome.size(); i++) {
if (chromosome[i] == target[i]) {
fitness++;
}
}
return fitness;
}
// Perform selection of parents based on fitness
vector<Chromosome> selection(const vector<Chromosome>& population, const Chromosome& target, int numParents) {
vector<Chromosome> selectedParents(population);
sort(selectedParents.begin(), selectedParents.end(), [&](const Chromosome& a, const Chromosome& b) {
return fitnessFunction(a, target) > fitnessFunction(b, target);
});
selectedParents.resize(numParents);
return selectedParents;
}
// Perform crossover to produce offspring
vector<Chromosome> crossover(const vector<Chromosome>& parents, int numOffspring) {
vector<Chromosome> offspring;
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dis(0, parents[0].size() - 1);
for (int i = 0; i < numOffspring; i++) {
const Chromosome& parent1 = parents[dis(gen)];
const Chromosome& parent2 = parents[dis(gen)];
int crossoverPoint = dis(gen);
Chromosome child(parent1.begin(), parent1.begin() + crossoverPoint);
child.insert(child.end(), parent2.begin() + crossoverPoint, parent2.end());
offspring.push_back(child);
}
return offspring;
}
// Perform mutation on offspring
vector<Chromosome> mutation(vector<Chromosome>& offspring, double mutationRate) {
random_device rd;
mt19937 gen(rd());
uniform_real_distribution<> dis(0.0, 1.0);
for (Chromosome& chromosome : offspring) {
for (int& bit : chromosome) {
if (dis(gen) < mutationRate) {
bit = 1 - bit; // Flip the bit
}
}
}
return offspring;
}
// Perform a classical genetic algorithm to evolve towards a target binary sequence
Chromosome geneticAlgorithm(const Chromosome& target, int chromosomeLength, int populationSize, int numGenerations, double mutationRate) {
vector<Chromosome> population = generatePopulation(populationSize, chromosomeLength);
for (int generation = 0; generation < numGenerations; generation++) {
vector<Chromosome> parents = selection(population, target, populationSize / 2);
vector<Chromosome> offspring = crossover(parents, populationSize - parents.size());
offspring = mutation(offspring, mutationRate);
population =
|
Subsets and Splits