newtensprog 1.0__tar.gz

newtensprog-1.0/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: newtensprog
+Version: 1.0

newtensprog-1.0/newtensprog.egg-info/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: newtensprog
+Version: 1.0

newtensprog-1.0/newtensprog.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+setup.py
+newtensprog.egg-info/PKG-INFO
+newtensprog.egg-info/SOURCES.txt
+newtensprog.egg-info/dependency_links.txt
+newtensprog.egg-info/top_level.txt
+prog/__init__.py
+prog/p1.py
+prog/p13.py
+prog/p14.py
+prog/p15.py
+prog/p16.py
+prog/p17.py
+prog/p2.py
+prog/p3.py
+prog/p4.py
+prog/p5.py
+prog/p6.py

newtensprog-1.0/newtensprog.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

newtensprog-1.0/newtensprog.egg-info/top_level.txt

@@ -0,0 +1 @@
+prog

newtensprog-1.0/prog/__init__.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+def _show(filename):
+    package_dir = Path(__file__).parent
+    print((package_dir / filename).read_text())
+
+
+def p1():
+    _show("p1.py")
+
+def p2():
+    _show("p2.py")
+
+def p3():
+    _show("p3.py")
+
+def p4():
+    _show("p4.py")
+
+def p5():
+    _show("p5.py")
+
+def p6():
+    _show("p6.py")
+
+    
+
+def p13():
+    _show("p13.py")
+
+def p14():
+    _show("p14.py")
+
+def p15():
+    _show("p15.py")
+
+def p16():
+    _show("p16.py")
+
+def p17():
+    _show("p17.py")
+

newtensprog-1.0/prog/p1.py

@@ -0,0 +1,96 @@
+class HashTable:
+    def __init__(self, size):
+        self.size = size
+        self.table = [None] * size
+
+    # Hash function (first 3 characters)
+    def hash_function(self, url):
+        return sum(ord(c) for c in url[:3]) % self.size
+
+    # Insert with detailed tracing
+    def insert(self, url):
+        index = self.hash_function(url)
+        origin_index = index
+        steps = []
+
+        # If empty slot found immediately
+        if self.table[index] is None:
+            self.table[index] = url
+            action = f"Inserted at index {index}"
+            return index, action
+
+        # Collision case
+        steps.append(index)
+
+        while self.table[index] is not None:
+            index = (index + 1) % self.size
+            steps.append(index)
+
+            if index == origin_index:
+                return origin_index, "Hash table full"
+
+        self.table[index] = url
+        action = f"Collision at {steps[0]} -> checked {steps[1:]} -> inserted at index {index}"
+        return steps[0], action
+
+    # Search (unchanged logic)
+    def search(self, url):
+        index = self.hash_function(url)
+        start = index
+
+        while self.table[index] is not None:
+            if self.table[index] == url:
+                return index
+            index = (index + 1) % self.size
+            if index == start:
+                break
+        return None
+
+    # Delete
+    def delete(self, url):
+        index = self.search(url)
+        if index is not None:
+            self.table[index] = None
+            return index
+        return None
+
+    # Display
+    def display(self):
+        print("\nFinal Hash Table:")
+        print("-" * 40)
+        for i, val in enumerate(self.table):
+            print(f"Index {i}: {val}")
+        print("-" * 40)
+
+
+# ---------------- MAIN PROGRAM ---------------- #
+
+urls = ["google.com", "gmail.com", "geeksforgeeks.org", "gutenberg.org","github.com","gitlab.com","gog.com","yahoo.com","bing.com"]
+
+cache = HashTable(10)
+
+print("\nStep | URL                     | Hash Index | Action")
+print("-" * 70)
+
+for step, url in enumerate(urls, start=1):
+    hash_index, action = cache.insert(url)
+    print(f"{step:>4} | {url:<22} | {hash_index:^10} | {action}")
+
+# Search
+search_url = "gmail.com"
+result = cache.search(search_url)
+if result is not None:
+    print(f"\nSearching '{search_url}': Found at index {result}")
+else:
+    print(f"\nSearching '{search_url}': Not Found")
+
+# Delete
+delete_url = "gmail.com"
+deleted_index = cache.delete(delete_url)
+if deleted_index is not None:
+    print(f"\nDeleting '{delete_url}' from index {deleted_index}")
+else:
+    print(f"\n'{delete_url}' not found for deletion")
+
+# Display final table
+cache.display()

newtensprog-1.0/prog/p13.py

@@ -0,0 +1,148 @@
+import pandas as pd
+import numpy as np
+import torch
+
+from torch.utils.data import Dataset, DataLoader
+
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+
+
+# Step 1: Custom Dataset class
+class TitanicDataset(Dataset):
+
+    def __init__(self, features, labels):
+        self.X = torch.tensor(features, dtype=torch.float32)
+        self.y = torch.tensor(labels, dtype=torch.float32)
+
+    def __len__(self):
+        return len(self.X)
+
+    def __getitem__(self, idx):
+        return self.X[idx], self.y[idx]
+
+
+# Step 2: Load dataset
+def load_titanic_data(path):
+    df = pd.read_csv(path)
+    return df
+
+
+# Step 3: Clean column names and handle missing values
+def fill_missing_values(df):
+
+    df.columns = df.columns.str.strip().str.lower()
+
+    df['age'] = df['age'].fillna(df['age'].median())
+    df['fare'] = df['fare'].fillna(df['fare'].median())
+
+    df['sex'] = df['sex'].astype(str)
+
+    return df
+
+
+# Step 4: Select relevant features
+def select_features(df):
+
+    return df[
+        ['pclass', 'sex', 'age', 'fare', 'survived']
+    ]
+
+
+# Step 5: Feature transformation using sklearn pipeline
+def preprocess_titanic_features(df):
+
+    y = df['survived'].values
+    X = df.drop(columns=['survived'])
+
+    numeric_features = ['age', 'fare']
+    categorical_features = ['pclass', 'sex']
+
+    numeric_transformer = Pipeline(
+        steps=[
+            ('scaler', StandardScaler())
+        ]
+    )
+
+    categorical_transformer = Pipeline(
+        steps=[
+            (
+                'onehot',
+                OneHotEncoder(
+                    handle_unknown='ignore',
+                    sparse_output=False
+                )
+            )
+        ]
+    )
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            (
+                'num',
+                numeric_transformer,
+                numeric_features
+            ),
+            (
+                'cat',
+                categorical_transformer,
+                categorical_features
+            )
+        ]
+    )
+
+    X_processed = preprocessor.fit_transform(X)
+
+    return X_processed, y, preprocessor
+
+
+# Step 6: Create DataLoader
+def get_titanic_dataloader(X, y, batch_size=32):
+
+    dataset = TitanicDataset(X, y)
+
+    dataloader = DataLoader(
+        dataset,
+        batch_size=batch_size,
+        shuffle=True
+    )
+
+    return dataloader
+
+
+# Step 7: Combine all steps into a full pipeline
+def prepare_titanic_pipeline(csv_path, batch_size=32):
+
+    df = load_titanic_data(csv_path)
+
+    df = fill_missing_values(df)
+
+    df = select_features(df)
+
+    X, y, transformer = preprocess_titanic_features(df)
+
+    dataloader = get_titanic_dataloader(
+        X,
+        y,
+        batch_size
+    )
+
+    return dataloader, transformer
+
+
+# Execution
+dataloader, transformer = prepare_titanic_pipeline(
+    "C:/Users/user1/Downloads/Titanic-Dataset.csv",
+    batch_size=16
+)
+
+print(dataloader)
+print(transformer)
+
+for X_batch, y_batch in dataloader:
+
+    print("X shape:", X_batch.shape)
+    print("y shape:", y_batch.shape)
+
+    break

newtensprog-1.0/prog/p14.py

@@ -0,0 +1,186 @@
+import pandas as pd
+import numpy as np
+from PIL import Image
+import os
+
+
+class UnifiedDataProcessor:
+    def __init__(self):
+        self.data = None
+        self.metadata = {}
+
+    def load_csv(self, file_path):
+        self.data = pd.read_csv(file_path)
+        self.metadata = {
+            'source': file_path,
+            'type': 'tabular',
+            'columns': list(self.data.columns),
+            'size': os.path.getsize(file_path)
+        }
+
+    def load_excel(self, file_path, sheet_name=0):
+        self.data = pd.read_excel(file_path, sheet_name=sheet_name)
+        self.metadata = {
+            'source': file_path,
+            'type': 'tabular',
+            'columns': list(self.data.columns),
+            'size': os.path.getsize(file_path),
+            'sheet': sheet_name
+        }
+
+    def load_text(self, file_path):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        self.data = pd.DataFrame({
+            'text_content': [content],
+            'char_count': [len(content)],
+            'word_count': [len(content.split())],
+            'line_count': [len(content.splitlines())]
+        })
+
+        self.metadata = {
+            'source': file_path,
+            'type': 'text',
+            'size': os.path.getsize(file_path)
+        }
+
+    def load_image(self, file_path):
+        img = Image.open(file_path)
+        img_array = np.array(img)
+
+        self.data = pd.DataFrame({
+            'file_path': [file_path],
+            'width': [img.width],
+            'height': [img.height],
+            'channels': [img_array.shape[2] if len(img_array.shape) > 2 else 1],
+            'dtype': [img_array.dtype],
+            'size_kb': [os.path.getsize(file_path) / 1024]
+        })
+
+        self.metadata = {
+            'source': file_path,
+            'type': 'image',
+            'size': os.path.getsize(file_path),
+            'format': img.format
+        }
+
+    def get_unified_representation(self):
+        if self.data is None:
+            return pd.DataFrame()
+
+        for key, value in self.metadata.items():
+            if key not in self.data.columns:
+                if isinstance(value, (str, int, float)):
+                    self.data[key] = value
+                else:
+                    self.data[key] = str(value)
+
+        return self.data
+
+
+def save_to_file(df, filename):
+    try:
+        df.to_csv(filename, index=False)
+        print(f"Successfully saved to {os.path.abspath(filename)}")
+        return True
+
+    except PermissionError:
+        try:
+            home_dir = os.path.expanduser("~")
+            new_path = os.path.join(home_dir, filename)
+            df.to_csv(new_path, index=False)
+            print(f"Saved to {new_path}")
+            return True
+
+        except Exception as e:
+            print(f"Failed to save file: {str(e)}")
+            return False
+
+    except Exception as e:
+        print(f"Error saving file: {str(e)}")
+        return False
+
+
+def create_sample_files():
+    sample_dir = os.path.join(
+        os.path.expanduser("~"),
+        "data_processor_samples"
+    )
+    os.makedirs(sample_dir, exist_ok=True)
+
+    files_created = []
+
+    csv_path = os.path.join(sample_dir, "sample.csv")
+    if not os.path.exists(csv_path):
+        pd.DataFrame({
+            'id': [1, 2, 3],
+            'value': ['A', 'B', 'C']
+        }).to_csv(csv_path, index=False)
+
+    excel_path = os.path.join(sample_dir, "sample.xlsx")
+    if not os.path.exists(excel_path):
+        pd.DataFrame({
+            'id': [1, 2, 3],
+            'score': [85, 90, 78]
+        }).to_excel(excel_path, index=False)
+
+    text_path = os.path.join(sample_dir, "sample.txt")
+    if not os.path.exists(text_path):
+        with open(text_path, 'w') as f:
+            f.write(
+                "This is a sample text file.\n"
+                "It contains multiple lines.\n"
+            )
+
+    img_path = os.path.join(sample_dir, "sample.jpg")
+    if not os.path.exists(img_path):
+        Image.new('RGB', (100, 100), color='red').save(img_path)
+
+    return {
+        'CSV': csv_path,
+        'Excel': excel_path,
+        'Text': text_path,
+        'Image': img_path
+    }
+
+
+def main():
+    processor = UnifiedDataProcessor()
+    file_paths = create_sample_files()
+    results = []
+
+    for file_type, file_path in file_paths.items():
+        try:
+            if file_type == 'CSV':
+                processor.load_csv(file_path)
+
+            elif file_type == 'Excel':
+                processor.load_excel(file_path)
+
+            elif file_type == 'Text':
+                processor.load_text(file_path)
+
+            elif file_type == 'Image':
+                processor.load_image(file_path)
+
+            unified_df = processor.get_unified_representation()
+            results.append(unified_df)
+
+            print(f"\nProcessed {file_type}:")
+            print(unified_df.head())
+
+        except Exception as e:
+            print(f"\nError processing {file_type}: {str(e)}")
+
+    if results:
+        final_df = pd.concat(results, ignore_index=True)
+
+        print("\nFinal Unified Representation:")
+        print(final_df)
+
+        save_to_file(final_df, 'unified_data.csv')
+
+
+if __name__ == "__main__":
+    main()

newtensprog-1.0/prog/p15.py

@@ -0,0 +1,147 @@
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
+import torch.nn as nn
+import torch.optim as optim
+
+
+# Transformations
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize(
+        (0.1307,),
+        (0.3081,)
+    )  # Standard MNIST normalization
+])
+
+
+# Load training dataset
+train_dataset = datasets.MNIST(
+    root='./data',
+    train=True,
+    download=False,
+    transform=transform
+)
+
+
+# Load testing dataset
+test_dataset = datasets.MNIST(
+    root='./data',
+    train=False,
+    download=False,
+    transform=transform
+)
+
+
+# Data loaders
+train_loader = DataLoader(
+    train_dataset,
+    batch_size=64,
+    shuffle=True
+)
+
+test_loader = DataLoader(
+    test_dataset,
+    batch_size=1000,
+    shuffle=False
+)
+
+
+# CNN Model
+class SimpleCNN(nn.Module):
+
+    def __init__(self):
+        super(SimpleCNN, self).__init__()
+
+        self.conv = nn.Sequential(
+            nn.Conv2d(1, 32, 3, 1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(32, 64, 3, 1),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
+        )
+
+        self.fc = nn.Sequential(
+            nn.Flatten(),
+
+            nn.Linear(64 * 5 * 5, 128),
+            nn.ReLU(),
+
+            nn.Linear(128, 10)
+        )
+
+    def forward(self, x):
+
+        x = self.conv(x)
+        x = self.fc(x)
+
+        return x
+
+
+# Device configuration
+device = torch.device(
+    'cuda' if torch.cuda.is_available() else 'cpu'
+)
+
+model = SimpleCNN().to(device)
+
+criterion = nn.CrossEntropyLoss()
+
+optimizer = optim.Adam(
+    model.parameters(),
+    lr=0.001
+)
+
+
+# Training loop
+for epoch in range(1, 4):
+
+    model.train()
+
+    for data, target in train_loader:
+
+        data = data.to(device)
+        target = target.to(device)
+
+        optimizer.zero_grad()
+
+        output = model(data)
+
+        loss = criterion(output, target)
+
+        loss.backward()
+
+        optimizer.step()
+
+    print(f'Epoch {epoch}, Loss: {loss.item()}')
+
+
+# Evaluation
+model.eval()
+
+correct = 0
+total = 0
+
+with torch.no_grad():
+
+    for data, target in test_loader:
+
+        data = data.to(device)
+        target = target.to(device)
+
+        outputs = model(data)
+
+        _, predicted = torch.max(outputs.data, 1)
+
+        total += target.size(0)
+
+        correct += (
+            predicted == target
+        ).sum().item()
+
+print(
+    f'Test Accuracy: {100 * correct / total:.2f}%'
+)

newtensprog-1.0/prog/p16.py

@@ -0,0 +1,174 @@
+import tensorflow as tf
+from tensorflow.keras.applications import VGG19
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import (
+    Dense,
+    Flatten,
+    Dropout
+)
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.preprocessing.image import (
+    ImageDataGenerator
+)
+import matplotlib.pyplot as plt
+import os
+# Dataset paths
+dataset_path = r"C:/Users/user1/Downloads/ci"  
+# Change this to your dataset path
+
+train_dir = os.path.join(
+    dataset_path,
+    'train'
+)
+
+val_dir = os.path.join(
+    dataset_path,
+    'validation'
+)
+
+test_dir = os.path.join(
+    dataset_path,
+    'test'
+)
+
+
+# Image settings
+img_size = (224, 224)
+
+batch_size = 32
+
+
+# Data generators with augmentation
+# for training
+train_datagen = ImageDataGenerator(
+    rescale=1.0 / 255,
+    rotation_range=20,
+    width_shift_range=0.2,
+    height_shift_range=0.2,
+    shear_range=0.2,
+    zoom_range=0.2,
+    horizontal_flip=True,
+    fill_mode='nearest'
+)
+# Validation and test generators
+val_test_datagen = ImageDataGenerator(
+    rescale=1.0 / 255
+)
+# Training data generator
+train_generator = train_datagen.flow_from_directory(
+    train_dir,
+    target_size=img_size,
+    batch_size=batch_size,
+    class_mode='binary'
+)
+# Validation data generator
+val_generator = val_test_datagen.flow_from_directory(
+    val_dir,
+
+    target_size=img_size,
+
+    batch_size=batch_size,
+
+    class_mode='binary'
+)
+
+
+# Test data generator
+test_generator = val_test_datagen.flow_from_directory(
+    test_dir,
+
+    target_size=img_size,
+
+    batch_size=batch_size,
+
+    class_mode='binary',
+
+    shuffle=False
+)
+
+
+# Function to create VGG19 model
+def create_vgg19_from_scratch(num_classes):
+
+    model = VGG19(
+        weights='imagenet',
+
+        include_top=False,
+
+        input_shape=(224, 224, 3)
+    )
+
+    # Make all layers trainable
+    for layer in model.layers:
+        layer.trainable = True
+
+    # Add custom layers
+    x = Flatten()(model.output)
+
+    x = Dense(
+        512,
+        activation='relu'
+    )(x)
+
+    x = Dropout(0.5)(x)
+
+    predictions = Dense(
+        num_classes,
+        activation='sigmoid'
+    )(x)
+
+    # Final model
+    model = Model(
+        inputs=model.input,
+        outputs=predictions
+    )
+
+    # Compile model
+    model.compile(
+        optimizer=Adam(
+            learning_rate=0.0001
+        ),
+
+        loss='binary_crossentropy',
+
+        metrics=['accuracy']
+    )
+
+    return model
+# Number of output classes
+num_classes = 1
+# Create model
+scratch_model = create_vgg19_from_scratch(
+    num_classes
+)
+# Train model
+scratch_history = scratch_model.fit(
+    train_generator,
+
+    steps_per_epoch=(
+        train_generator.samples // batch_size
+    ),
+
+    epochs=10,
+
+    validation_data=val_generator,
+
+    validation_steps=(
+        val_generator.samples // batch_size
+    )
+)
+
+# Plot training and validation accuracy
+plt.plot(
+    scratch_history.history['accuracy'],
+    label='Train Accuracy'
+)
+plt.plot(
+    scratch_history.history['val_accuracy'],
+    label='Validation Accuracy'
+)
+plt.title('Model Accuracy')
+plt.xlabel('Epoch')
+plt.ylabel('Accuracy')
+plt.legend()
+plt.show()

newtensprog-1.0/prog/p17.py

@@ -0,0 +1,67 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import tensorflow as tf
+from tensorflow.keras.models import Model
+from tensorflow.keras.preprocessing import image
+from tensorflow.keras.applications import VGG19
+# Load image
+img_path = (
+    "C:/Users/user1/Downloads/ci/validation/"
+    "Uninfected/C1_thinF_IMG_20150604_104919_cell_132.png")
+img = image.load_img(img_path, target_size=(224, 224))
+img_tensor = np.expand_dims( image.img_to_array(img), axis=0) / 255.0
+# Load model
+scratch_model = VGG19( weights='imagenet', include_top=True)
+layer_outputs = [layer.output for layer in scratch_model.layers if 'conv' in layer.name]
+activation_model = Model(inputs=scratch_model.input,outputs=layer_outputs)
+# Get activations
+activations = activation_model.predict(img_tensor)
+for i, act in enumerate(activations[:3]):
+    fig, axs = plt.subplots(1,6,figsize=(15, 5))
+    for j in range(6):
+        axs[j].imshow(act[0, :, :, j],cmap='viridis')
+        axs[j].axis('off')
+    plt.suptitle(f'Activations: {scratch_model.layers[i].name}')
+    plt.show()
+# Visualize filters
+filters, _ = scratch_model.get_layer('block1_conv1').get_weights()
+fig, axs = plt.subplots(1,6,figsize=(15, 5))
+for i in range(6):
+    f = ( filters[:, :, :, i] - filters.min()) / (filters.max() - filters.min())
+    axs[i].imshow(f[:, :, 0],cmap='gray')
+    axs[i].axis('off')
+plt.suptitle('First Layer Filters')
+plt.show()
+# Grad-CAM
+def grad_cam(model, img_tensor,layer_name='block5_conv4'):
+    grad_model = Model(
+        [model.inputs],
+        [
+            model.get_layer(layer_name).output,
+            model.output
+        ]
+    )
+    with tf.GradientTape() as tape:
+        conv_out, pred = grad_model(img_tensor)
+        grads = tape.gradient(pred[:, tf.argmax(pred[0])],conv_out)[0]
+    weights = tf.reduce_mean(grads,axis=(0, 1))
+    cam = np.dot(conv_out[0], weights)
+    cam = np.maximum(cam, 0)
+    cam = cv2.resize(cam, (224, 224))
+    cam = (cam - cam.min()) / (cam.max() - cam.min())
+    return cam
+
+
+# Generate heatmap
+heatmap = grad_cam(scratch_model,img_tensor)
+orig = cv2.imread(img_path)
+orig = cv2.resize(orig,(224, 224))
+overlay = cv2.applyColorMap(np.uint8(255 * heatmap),cv2.COLORMAP_JET)
+superimposed = cv2.addWeighted(orig,0.6,overlay,0.4,0)
+
+# Display result
+plt.imshow(cv2.cvtColor(superimposed,cv2.COLOR_BGR2RGB))
+plt.title('Grad-CAM')
+plt.axis('off')
+plt.show()

newtensprog-1.0/prog/p3.py

@@ -0,0 +1,29 @@
+import heapq
+
+# Function to schedule jobs using Min-Heap
+def schedule_jobs(jobs):
+    print("--- CPU Job Scheduling using Min-Heap ---")
+    print("Jobs inserted:", jobs)
+    
+    # Create an empty heap
+    min_heap = []
+    
+    # Insert jobs into heap (processing_time, job_id)
+    for job_id, time in jobs:
+        heapq.heappush(min_heap, (time, job_id))
+    
+    print("\nOrder of execution:")
+    
+    order = 1
+    # Process jobs in order of shortest time
+    while min_heap:
+        time, job_id = heapq.heappop(min_heap)
+        print(f"{order}. {job_id} (Time: {time})")
+        order += 1
+
+
+# Sample Input
+jobs = [("Job1", 12), ("Job2", 5), ("Job3", 8), ("Job4", 3)]
+
+# Run the scheduler
+schedule_jobs(jobs)

newtensprog-1.0/prog/p4.py

@@ -0,0 +1,49 @@
+import heapq
+
+class EmergencyRoom:
+    def __init__(self):
+        self.heap = []
+
+    # Insert patient into max-heap
+    def insert_patient(self, name, severity):
+        # Use negative severity to simulate max-heap
+        heapq.heappush(self.heap, (-severity, name))
+
+    # Treat patient with highest severity
+    def treat_patient(self):
+        if self.heap:
+            severity, name = heapq.heappop(self.heap)
+            return name, -severity
+        return None
+
+    # Display treatment order
+    def display_treatment_order(self):
+        order = []
+        count = 1
+        while self.heap:
+            name, severity = self.treat_patient()
+            order.append((count, name, severity))
+            count += 1
+        return order
+
+
+# Sample Input
+patients = [("Alice", 45), ("Bob", 90), ("Eve", 30), ("Charlie", 75)]
+
+# Create Emergency Room system
+er = EmergencyRoom()
+
+print("--- Emergency Room Priority Queue using Max-Heap ---")
+
+# Insert patients
+for name, severity in patients:
+    er.insert_patient(name, severity)
+
+print("Patients inserted:", patients)
+
+# Display treatment order
+print("Order of treatment:")
+treatment_order = er.display_treatment_order()
+
+for num, name, severity in treatment_order:
+    print(f"{num}. {name} (Severity: {severity})")

newtensprog-1.0/prog/p5.py

@@ -0,0 +1,203 @@
+class Node:
+    def __init__(self, name, phone):
+        self.name = name
+        self.phone = phone
+        self.left = None
+        self.right = None
+        self.height = 1
+
+
+class AVLContactBook:
+    def __init__(self):
+        self.root = None
+
+    def height(self, node):
+        return node.height if node else 0
+
+    def get_balance(self, node):
+        return self.height(node.left) - self.height(node.right) if node else 0
+
+    def right_rotate(self, y):
+        print(f"Rotation performed: Right Rotation at node {y.name}")
+        x = y.left
+        T2 = x.right
+
+        x.right = y
+        y.left = T2
+
+        y.height = 1 + max(self.height(y.left), self.height(y.right))
+        x.height = 1 + max(self.height(x.left), self.height(x.right))
+
+        return x
+
+    def left_rotate(self, x):
+        print(f"Rotation performed: Left Rotation at node {x.name}")
+        y = x.right
+        T2 = y.left
+
+        y.left = x
+        x.right = T2
+
+        x.height = 1 + max(self.height(x.left), self.height(x.right))
+        y.height = 1 + max(self.height(y.left), self.height(y.right))
+
+        return y
+
+    def insert(self, node, name, phone):
+        if not node:
+            print(f"Inserted: {name}")
+            return Node(name, phone)
+
+        if name < node.name:
+            node.left = self.insert(node.left, name, phone)
+        elif name > node.name:
+            node.right = self.insert(node.right, name, phone)
+        else:
+            return node
+
+        node.height = 1 + max(self.height(node.left), self.height(node.right))
+        balance = self.get_balance(node)
+
+        if balance > 1 and name < node.left.name:
+            return self.right_rotate(node)
+
+        if balance < -1 and name > node.right.name:
+            return self.left_rotate(node)
+
+        if balance > 1 and name > node.left.name:
+            print(f"Rotation performed: Left Right Rotation at node {node.name}")
+            node.left = self.left_rotate(node.left)
+            return self.right_rotate(node)
+
+        if balance < -1 and name < node.right.name:
+            print(f"Rotation performed: Right Left Rotation at node {node.name}")
+            node.right = self.right_rotate(node.right)
+            return self.left_rotate(node)
+
+        return node
+
+    def min_value_node(self, node):
+        current = node
+        while current.left:
+            current = current.left
+        return current
+
+    def delete(self, node, name):
+        if not node:
+            return node
+
+        if name < node.name:
+            node.left = self.delete(node.left, name)
+        elif name > node.name:
+            node.right = self.delete(node.right, name)
+        else:
+            print(f"Deleting: {name}")
+            if not node.left:
+                return node.right
+            elif not node.right:
+                return node.left
+
+            temp = self.min_value_node(node.right)
+            node.name = temp.name
+            node.phone = temp.phone
+            node.right = self.delete(node.right, temp.name)
+
+        if not node:
+            return node
+
+        node.height = 1 + max(self.height(node.left), self.height(node.right))
+        balance = self.get_balance(node)
+
+        if balance > 1 and self.get_balance(node.left) >= 0:
+            print("Rebalancing performed")
+            return self.right_rotate(node)
+
+        if balance < -1 and self.get_balance(node.right) <= 0:
+            print("Rebalancing performed")
+            return self.left_rotate(node)
+
+        if balance > 1 and self.get_balance(node.left) < 0:
+            print("Rebalancing performed")
+            node.left = self.left_rotate(node.left)
+            return self.right_rotate(node)
+
+        if balance < -1 and self.get_balance(node.right) > 0:
+            print("Rebalancing performed")
+            node.right = self.right_rotate(node.right)
+            return self.left_rotate(node)
+
+        return node
+
+    def inorder(self, node):
+        if node:
+            self.inorder(node.left)
+            print(f"{node.name} -> {node.phone}")
+            self.inorder(node.right)
+
+
+# ===================== MAIN PROGRAM =====================
+
+# -------- Example 1 --------
+book = AVLContactBook()
+
+contacts1 = [
+    ("David", "9876543210"),
+    ("Alice", "9123456789"),
+    ("Charlie", "9988776655"),
+    ("Eve", "9090909090")
+]
+
+print("\n--- Contact Book using AVL Tree (Example 1) ---")
+for name, phone in contacts1:
+    book.root = book.insert(book.root, name, phone)
+
+print("\nIn-Order Display (Alphabetical):")
+book.inorder(book.root)
+
+book.root = book.delete(book.root, "Charlie")
+
+print("\nAfter Deletion:")
+book.inorder(book.root)
+
+
+# -------- Example 2 --------
+book2 = AVLContactBook()
+
+contacts2 = [
+    ("Zara", "9000000001"),
+    ("Yash", "9000000002"),
+    ("Xander", "9000000003"),
+    ("Will", "9000000004"),
+    ("Victor", "9000000005")
+]
+
+print("\n--- Example 2 (More Rotations) ---")
+for name, phone in contacts2:
+    book2.root = book2.insert(book2.root, name, phone)
+
+print("\nIn-Order Display:")
+book2.inorder(book2.root)
+
+
+# -------- Example 3 --------
+book3 = AVLContactBook()
+
+contacts3 = [
+    ("John", "111"),
+    ("Emma", "222"),
+    ("Olivia", "333"),
+    ("Liam", "444"),
+    ("Noah", "555")
+]
+
+print("\n--- Example 3 (Mixed Insert/Delete) ---")
+for name, phone in contacts3:
+    book3.root = book3.insert(book3.root, name, phone)
+
+print("\nBefore Deletion:")
+book3.inorder(book3.root)
+
+book3.root = book3.delete(book3.root, "Emma")
+
+print("\nAfter Deleting Emma:")
+book3.inorder(book3.root)

newtensprog-1.0/prog/p6.py

@@ -0,0 +1,159 @@
+from collections import deque
+
+# ---------------- B-Tree Node ----------------
+class BTreeNode:
+    def __init__(self, leaf=False):
+        self.leaf = leaf
+        self.keys = []
+        self.children = []
+
+
+# ---------------- B-Tree ----------------
+class BTree:
+    def __init__(self, order):
+        self.root = BTreeNode(True)
+        self.order = order
+        self.max_keys = order - 1
+
+    # Search operation
+    def search(self, node, key):
+        i = 0
+
+        while i < len(node.keys) and key > node.keys[i]:
+            i += 1
+
+        if i < len(node.keys) and key == node.keys[i]:
+            return True
+
+        if node.leaf:
+            return False
+
+        return self.search(node.children[i], key)
+
+    # Split child
+    def split_child(self, parent, index):
+        child = parent.children[index]
+
+        mid = len(child.keys) // 2
+        mid_key = child.keys[mid]
+
+        new_node = BTreeNode(child.leaf)
+
+        new_node.keys = child.keys[mid + 1:]
+        child.keys = child.keys[:mid]
+
+        if not child.leaf:
+            new_node.children = child.children[mid + 1:]
+            child.children = child.children[:mid + 1]
+
+        parent.keys.insert(index, mid_key)
+        parent.children.insert(index + 1, new_node)
+
+    # Insert into non-full node
+    def insert_non_full(self, node, key):
+        i = len(node.keys) - 1
+
+        if node.leaf:
+            node.keys.append(None)
+
+            while i >= 0 and key < node.keys[i]:
+                node.keys[i + 1] = node.keys[i]
+                i -= 1
+
+            node.keys[i + 1] = key
+
+        else:
+            while i >= 0 and key < node.keys[i]:
+                i -= 1
+
+            i += 1
+
+            if len(node.children[i].keys) == self.max_keys:
+                self.split_child(node, i)
+
+                if key > node.keys[i]:
+                    i += 1
+
+            self.insert_non_full(node.children[i], key)
+
+    # Insert operation
+    def insert(self, key):
+        root = self.root
+
+        if len(root.keys) == self.max_keys:
+            new_root = BTreeNode(False)
+            new_root.children.append(root)
+
+            self.split_child(new_root, 0)
+
+            self.root = new_root
+
+            self.insert_non_full(new_root, key)
+        else:
+            self.insert_non_full(root, key)
+
+    # Display level-wise
+    def display_level_order(self):
+        if not self.root:
+            return
+
+        q = deque()
+        q.append((self.root, 0))
+
+        current_level = 0
+
+        print("\nB-Tree Structure (Level-wise):")
+
+        while q:
+            node, level = q.popleft()
+
+            if level != current_level:
+                print()
+                current_level = level
+
+            print(f"{node.keys}", end=" | ")
+
+            for child in node.children:
+                q.append((child, level + 1))
+
+        print()
+
+    # Search wrapper
+    def search_key(self, key):
+        return self.search(self.root, key)
+
+
+# ---------------- Main Program ----------------
+if __name__ == "__main__":
+
+    # Predefined file list (BTree 1)
+    file1 = ["alpha.txt", "beta.txt", "delta.txt"]
+
+    # User input file list (BTree 2)
+    n = int(input("Enter number of files for file2: "))
+    file2 = [input(f"Enter filename {i+1}: ") for i in range(n)]
+
+    # Create two separate B-Trees
+    btree1 = BTree(order=3)
+    btree2 = BTree(order=3)
+
+    print("\n--- B-Tree 1 (file1) ---")
+    for f in file1:
+        btree1.insert(f)
+        print(f"Inserted: {f}")
+    btree1.display_level_order()
+
+    print("\n--- B-Tree 2 (file2) ---")
+    for f in file2:
+        btree2.insert(f)
+        print(f"Inserted: {f}")
+    btree2.display_level_order()
+
+    # Search in both trees
+    search_file = input("\nEnter filename to search: ")
+
+    print("\nSearching in B-Tree 1...")
+    print("Found" if btree1.search_key(search_file) else "Not Found")
+
+    print("Searching in B-Tree 2...")
+    print("Found" if btree2.search_key(search_file) else "Not Found")

newtensprog-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

newtensprog-1.0/setup.py

@@ -0,0 +1,7 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="newtensprog",
+    version="1.0",
+    packages=find_packages(),
+)