numpysc-lib 1.1.1__tar.gz

numpysc_lib-1.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chirag Vishwakarma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

numpysc_lib-1.1.1/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: numpysc-lib
+Version: 1.1.1
+Summary: Soft Computing Library
+Home-page: 
+Author: andhrew
+Author-email: xyz@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Soft Computing Library (`numpysc-lib`)
+
+A Python package that stores practical programs for **Soft Computing & Neural Networks** (Simple Neural Networks, Sigmoidal Functions, McCulloch-Pitts, Hebb Rule, Backpropagation, Fuzzy Sets, Perceptron) and prints their source code on demand, from Python or the terminal.
+
+Install it once with `pip`, then view any practical code on any machine without copying files around.
+
+---
+
+## Practicals Included
+
+| Practical | Topic / Description |
+|---|---|
+| `1A-Simple-Neural-Network` | Design a Simple Neural Network (SNN) with Ramp activation |
+| `1B-Sigmoidal-Functions` | Binary and Bipolar Sigmoidal Activation Functions |
+| `2A-McCulloch-Pitts Neural Network` | ANDNOT function using McCulloch-Pitts Neuron |
+| `2B-XOR function using McCulloch-Pitts Neural Network` | XOR function using McCulloch-Pitts Network |
+| `3-AND Hebb Rule Network` | AND function with Hebbian learning rule (bipolar inputs) |
+| `4-Back Propagation Problem` | Single-step forward & backward error propagation |
+| `5-Error Back Propagation` | Multi-epoch Error Backpropagation Training |
+| `6-Identity Operators` | Identity and Membership Operators in Python |
+| `7-Fuzzy` | Fuzzy Set Operations (Union, Intersection, Complement, Algebraic/Bounded Sum & Diff) |
+| `8-Perceptron` | Perceptron Learning Algorithm for Linear Classification |
+
+---
+
+## Step 1: Install
+
+```bash
+pip install numpysc-lib
+```
+
+To update to the latest version:
+
+```bash
+pip install --upgrade numpysc-lib
+```
+
+Requires Python 3.6 or newer.
+
+---
+
+## Step 2: View the programs
+
+### Option A: From the terminal
+
+Show all practicals:
+
+```bash
+numpysc
+# or
+numpysc-lib
+```
+
+Show a single practical (type the name or partial name):
+
+```bash
+numpysc "1A-Simple-Neural-Network"
+numpysc "7-Fuzzy"
+numpysc "8-Perceptron"
+```
+
+### Option B: From Python
+
+```python
+import numpysc_lib
+
+numpysc_lib.show_codes()                           # Show all practicals
+numpysc_lib.show_codes("7-Fuzzy")                  # Show specific practical
+numpysc_lib.show_codes("1A-Simple-Neural-Network") # Show specific practical
+```
+
+### Option C: In Google Colab or Jupyter
+
+```python
+!pip install numpysc-lib
+import numpysc_lib
+numpysc_lib.show_codes("8-Perceptron")
+```
+
+---
+
+## Publishing a new version (for maintainers)
+
+1. Make any additions or updates in the `numpysc_lib/` folder.
+2. Increment `version` in `setup.py` (e.g. `1.1.2`).
+3. Clean old builds:
+   ```bash
+   rm -rf dist build *.egg-info
+   ```
+4. Build:
+   ```bash
+   python3 -m build
+   ```
+5. Check and Upload to PyPI:
+   ```bash
+   python3 -m twine upload dist/*
+   ```
+
+---
+
+## License
+
+MIT. See [LICENSE](LICENSE).

numpysc_lib-1.1.1/README.md

@@ -0,0 +1,103 @@
+# Soft Computing Library (`numpysc-lib`)
+
+A Python package that stores practical programs for **Soft Computing & Neural Networks** (Simple Neural Networks, Sigmoidal Functions, McCulloch-Pitts, Hebb Rule, Backpropagation, Fuzzy Sets, Perceptron) and prints their source code on demand, from Python or the terminal.
+
+Install it once with `pip`, then view any practical code on any machine without copying files around.
+
+---
+
+## Practicals Included
+
+| Practical | Topic / Description |
+|---|---|
+| `1A-Simple-Neural-Network` | Design a Simple Neural Network (SNN) with Ramp activation |
+| `1B-Sigmoidal-Functions` | Binary and Bipolar Sigmoidal Activation Functions |
+| `2A-McCulloch-Pitts Neural Network` | ANDNOT function using McCulloch-Pitts Neuron |
+| `2B-XOR function using McCulloch-Pitts Neural Network` | XOR function using McCulloch-Pitts Network |
+| `3-AND Hebb Rule Network` | AND function with Hebbian learning rule (bipolar inputs) |
+| `4-Back Propagation Problem` | Single-step forward & backward error propagation |
+| `5-Error Back Propagation` | Multi-epoch Error Backpropagation Training |
+| `6-Identity Operators` | Identity and Membership Operators in Python |
+| `7-Fuzzy` | Fuzzy Set Operations (Union, Intersection, Complement, Algebraic/Bounded Sum & Diff) |
+| `8-Perceptron` | Perceptron Learning Algorithm for Linear Classification |
+
+---
+
+## Step 1: Install
+
+```bash
+pip install numpysc-lib
+```
+
+To update to the latest version:
+
+```bash
+pip install --upgrade numpysc-lib
+```
+
+Requires Python 3.6 or newer.
+
+---
+
+## Step 2: View the programs
+
+### Option A: From the terminal
+
+Show all practicals:
+
+```bash
+numpysc
+# or
+numpysc-lib
+```
+
+Show a single practical (type the name or partial name):
+
+```bash
+numpysc "1A-Simple-Neural-Network"
+numpysc "7-Fuzzy"
+numpysc "8-Perceptron"
+```
+
+### Option B: From Python
+
+```python
+import numpysc_lib
+
+numpysc_lib.show_codes()                           # Show all practicals
+numpysc_lib.show_codes("7-Fuzzy")                  # Show specific practical
+numpysc_lib.show_codes("1A-Simple-Neural-Network") # Show specific practical
+```
+
+### Option C: In Google Colab or Jupyter
+
+```python
+!pip install numpysc-lib
+import numpysc_lib
+numpysc_lib.show_codes("8-Perceptron")
+```
+
+---
+
+## Publishing a new version (for maintainers)
+
+1. Make any additions or updates in the `numpysc_lib/` folder.
+2. Increment `version` in `setup.py` (e.g. `1.1.2`).
+3. Clean old builds:
+   ```bash
+   rm -rf dist build *.egg-info
+   ```
+4. Build:
+   ```bash
+   python3 -m build
+   ```
+5. Check and Upload to PyPI:
+   ```bash
+   python3 -m twine upload dist/*
+   ```
+
+---
+
+## License
+
+MIT. See [LICENSE](LICENSE).

numpysc_lib-1.1.1/numpysc_lib/1A-Simple-Neural-Network.py

@@ -0,0 +1,18 @@
+# Practical 1A: Design a Simple Neural Network (SNN)
+x = float(input("Enter the input x = "))
+b = float(input("Enter the bias b = "))
+w = float(input("Enter the weight w = "))
+
+# Calculating net input value
+net = (x * w) + b
+print("Net =", net)
+
+# Activation function (ramp)
+if net < 0:
+    out = 0
+elif 0 <= net <= 1:
+    out = net
+else:
+    out = 1
+
+print("Output =", out)

numpysc_lib-1.1.1/numpysc_lib/1B-Sigmoidal-Functions.py

@@ -0,0 +1,19 @@
+# Practical 1B: Binary and Bipolar Sigmoidal Functions
+import math
+
+x = float(input("Enter the input x = "))
+b = float(input("Enter the bias b = "))
+w = float(input("Enter the weight w = "))
+
+# Net input value
+net = (x * w) + b
+print("Net =", net)
+
+# Binary sigmoidal function
+binary_sigmoidal = 1 / (1 + math.exp(-net))
+
+# Bipolar sigmoidal function
+bipolar_sigmoidal = (1 - math.exp(-net)) / (1 + math.exp(-net))
+
+print("Binary Sigmoidal =", round(binary_sigmoidal, 2))
+print("Bipolar Sigmoidal =", round(bipolar_sigmoidal, 4))

numpysc_lib-1.1.1/numpysc_lib/2A-McCulloch-Pitts Neural Network.py

@@ -0,0 +1,27 @@
+# Practical 2A: ANDNOT function using McCulloch-Pitts Neural Network
+import numpy as np
+
+class McCullochPittsNeuron:
+    def __init__(self, weights, threshold):
+        self.weights = np.array(weights)
+        self.threshold = threshold
+
+    def activate(self, inputs):
+        weighted_sum = np.dot(inputs, self.weights)
+        return 1 if weighted_sum >= self.threshold else 0
+
+and_not = McCullochPittsNeuron(weights=[1, -1], threshold=1)
+
+print("A B | A AND NOT B")
+print("------------------")
+
+inputs = [
+    [0, 0],
+    [0, 1],
+    [1, 0],
+    [1, 1]
+]
+
+for x in inputs:
+    output = and_not.activate(x)
+    print(f"{x[0]} {x[1]} |      {output}")

numpysc_lib-1.1.1/numpysc_lib/2B-XOR function using McCulloch-Pitts Neural Network.py

@@ -0,0 +1,32 @@
+# Practical 2B: XOR function using McCulloch-Pitts Neural Network
+# XOR = (A OR B) AND (A NAND B)
+import numpy as np
+
+class McCullochPittsNeuron:
+    def __init__(self, weights, threshold):
+        self.weights = np.array(weights)
+        self.threshold = threshold
+
+    def activate(self, inputs):
+        weighted_sum = np.dot(inputs, self.weights)
+        return 1 if weighted_sum >= self.threshold else 0
+
+or_neuron = McCullochPittsNeuron(weights=[1, 1], threshold=1)
+nand_neuron = McCullochPittsNeuron(weights=[-2, -2], threshold=-3)
+and_neuron = McCullochPittsNeuron(weights=[1, 1], threshold=2)
+
+print("A B | XOR")
+print("------------")
+
+inputs = [
+    [0, 0],
+    [0, 1],
+    [1, 0],
+    [1, 1]
+]
+
+for x in inputs:
+    or_output = or_neuron.activate(x)
+    nand_output = nand_neuron.activate(x)
+    xor_output = and_neuron.activate([or_output, nand_output])
+    print(f"{x[0]} {x[1]} |  {xor_output}")

numpysc_lib-1.1.1/numpysc_lib/3-AND Hebb Rule Network.py

@@ -0,0 +1,36 @@
+# Practical 3: AND Hebb Rule Network (bipolar inputs and targets)
+import numpy as np
+
+# Input data
+X = np.array([
+    [-1, -1],
+    [-1,  1],
+    [ 1, -1],
+    [ 1,  1]
+])
+
+# Target output for AND
+Y = np.array([-1, -1, -1, 1])
+
+# Initialize weights and bias
+w = np.zeros(2)
+b = 0
+
+print("Initial Weights:", w)
+print("Initial Bias:", b)
+
+# Hebbian learning: w_new = w_old + x*y , b_new = b_old + y
+for i in range(len(X)):
+    w = w + X[i] * Y[i]
+    b = b + Y[i]
+
+print("\nFinal Weights:", w)
+print("Final Bias:", b)
+
+# Testing AND function
+print("\nTesting AND Function")
+print("Input\t\tTarget\tOutput")
+for i in range(len(X)):
+    net = np.dot(X[i], w) + b
+    output = 1 if net >= 0 else -1
+    print(f"{X[i]}\t{Y[i]}\t{output}")

numpysc_lib-1.1.1/numpysc_lib/4-Back Propagation Problem.py

@@ -0,0 +1,46 @@
+# Practical 4: Back Propagation Problem
+# Network: 1 input -> 1 hidden neuron (tanh) -> 1 output neuron (tanh)
+# Performs ONE forward pass and ONE backward pass (single weight update).
+import math
+
+weight_input_hidden = float(input("Enter weight from input to hidden neuron: "))
+bias_hidden = float(input("Enter bias of hidden neuron: "))
+weight_hidden_output = float(input("Enter weight from hidden to output neuron: "))
+bias_output = float(input("Enter bias of output neuron: "))
+learning_rate = float(input("Enter learning rate: "))
+input_value = float(input("Enter input value: "))
+target_output = float(input("Enter target output: "))
+
+# ---- Forward propagation ----
+net_hidden = weight_input_hidden * input_value + bias_hidden
+hidden_output = math.tanh(net_hidden)
+net_output = weight_hidden_output * hidden_output + bias_output
+predicted_output = math.tanh(net_output)
+
+# ---- Error ----
+error = target_output - predicted_output
+print("\nPredicted output =", predicted_output)
+print("Error (before update) =", error)
+
+# ---- Backpropagation (sensitivities = dE/dnet, E = (target - output)^2) ----
+output_sensitivity = -2 * (1 - predicted_output ** 2) * error
+hidden_sensitivity = (1 - hidden_output ** 2) * weight_hidden_output * output_sensitivity
+
+# ---- Update (gradient descent: new = old - learning_rate * gradient) ----
+updated_weight_hidden_output = weight_hidden_output - learning_rate * output_sensitivity * hidden_output
+updated_weight_input_hidden = weight_input_hidden - learning_rate * hidden_sensitivity * input_value
+updated_bias_output = bias_output - learning_rate * output_sensitivity
+updated_bias_hidden = bias_hidden - learning_rate * hidden_sensitivity
+
+# ---- Display results ----
+print("\n----- Updated Parameters -----")
+print("Updated Input -> Hidden Weight :", updated_weight_input_hidden)
+print("Updated Hidden -> Output Weight:", updated_weight_hidden_output)
+print("Updated Hidden Bias            :", updated_bias_hidden)
+print("Updated Output Bias            :", updated_bias_output)
+
+# ---- Check: error after the update should be smaller ----
+new_hidden = math.tanh(updated_weight_input_hidden * input_value + updated_bias_hidden)
+new_output = math.tanh(updated_weight_hidden_output * new_hidden + updated_bias_output)
+print("\nOutput after update =", new_output)
+print("Error (after update) =", target_output - new_output)

numpysc_lib-1.1.1/numpysc_lib/5-Error Back Propagation.py

@@ -0,0 +1,42 @@
+# Practical 5: Error Back Propagation Algorithm
+# Same network as Practical 4 (1 input -> 1 hidden tanh -> 1 output tanh),
+# but the forward/backward steps are REPEATED for many epochs until the error is small.
+import math
+
+weight_input_hidden = float(input("Enter weight from input to hidden neuron: "))
+bias_hidden = float(input("Enter bias of hidden neuron: "))
+weight_hidden_output = float(input("Enter weight from hidden to output neuron: "))
+bias_output = float(input("Enter bias of output neuron: "))
+learning_rate = float(input("Enter learning rate: "))
+input_value = float(input("Enter input value: "))
+target_output = float(input("Enter target output (between -1 and 1): "))
+epochs = int(input("Enter number of epochs: "))
+
+for epoch in range(1, epochs + 1):
+    # Forward propagation
+    net_hidden = weight_input_hidden * input_value + bias_hidden
+    hidden_output = math.tanh(net_hidden)
+    net_output = weight_hidden_output * hidden_output + bias_output
+    predicted_output = math.tanh(net_output)
+
+    # Error
+    error = target_output - predicted_output
+
+    # Backward propagation of error
+    output_sensitivity = -2 * (1 - predicted_output ** 2) * error
+    hidden_sensitivity = (1 - hidden_output ** 2) * weight_hidden_output * output_sensitivity
+
+    # Update weights and biases (gradient descent)
+    weight_hidden_output -= learning_rate * output_sensitivity * hidden_output
+    weight_input_hidden -= learning_rate * hidden_sensitivity * input_value
+    bias_output -= learning_rate * output_sensitivity
+    bias_hidden -= learning_rate * hidden_sensitivity
+
+    if epoch == 1 or epoch % max(1, epochs // 10) == 0 or epoch == epochs:
+        print(f"Epoch {epoch:5d} | Output = {predicted_output:.6f} | Error = {error:.6f}")
+
+print("\n----- Final Parameters -----")
+print("Input -> Hidden Weight :", weight_input_hidden)
+print("Hidden -> Output Weight:", weight_hidden_output)
+print("Hidden Bias            :", bias_hidden)
+print("Output Bias            :", bias_output)

numpysc_lib-1.1.1/numpysc_lib/6-Identity Operators.py

@@ -0,0 +1,20 @@
+# Practical 6: Membership Operators and Identity Operators
+
+# ---------- A. Identity Operators (is, is not) ----------
+list1 = [1, 2, 3]
+list2 = [1, 2, 3]
+list3 = list1
+
+print("list1 is list3:", list1 is list3)
+print("list1 is list2:", list1 is list2)
+print("list1 is not list2:", list1 is not list2)
+print("list1 is not list3:", list1 is not list3)
+
+# ---------- B. Membership Operators (in, not in) ----------
+numbers = [10, 20, 30, 40, 50]
+text = "Python programming"
+
+print("\n30 in numbers:", 30 in numbers)
+print("'Python' in text:", "Python" in text)
+print("60 not in numbers:", 60 not in numbers)
+print("'Java' not in text:", "Java" not in text)

numpysc_lib-1.1.1/numpysc_lib/7-Fuzzy.py

@@ -0,0 +1,35 @@
+# Practical 7: Fuzzy Set Operations
+A = {"x1": 0.2, "x2": 0.5, "x3": 0.8, "x4": 1.0}
+B = {"x1": 0.6, "x2": 0.4, "x3": 0.7, "x4": 0.3}
+
+def fuzzy_union(A, B):
+    return {x: max(A[x], B[x]) for x in A}
+
+def fuzzy_intersection(A, B):
+    return {x: min(A[x], B[x]) for x in A}
+
+def fuzzy_complement(A):
+    return {x: round(1 - A[x], 2) for x in A}
+
+def algebraic_sum(A, B):
+    return {x: round(A[x] + B[x] - A[x] * B[x], 2) for x in A}
+
+def algebraic_product(A, B):
+    return {x: round(A[x] * B[x], 2) for x in A}
+
+def bounded_sum(A, B):
+    return {x: round(min(1, A[x] + B[x]), 2) for x in A}
+
+def bounded_difference(A, B):
+    return {x: round(max(0, A[x] - B[x]), 2) for x in A}
+
+print("A =", A)
+print("B =", B)
+print("\n1. Union (A OR B):", fuzzy_union(A, B))
+print("2. Intersection (A AND B):", fuzzy_intersection(A, B))
+print("3. Complement (NOT A):", fuzzy_complement(A))
+print("4. Complement (NOT B):", fuzzy_complement(B))
+print("5. Algebraic Sum:", algebraic_sum(A, B))
+print("6. Algebraic Product:", algebraic_product(A, B))
+print("7. Bounded Sum:", bounded_sum(A, B))
+print("8. Bounded Difference (A - B):", bounded_difference(A, B))

numpysc_lib-1.1.1/numpysc_lib/8-Perceptron.py

@@ -0,0 +1,51 @@
+# Practical 8: Perceptron Learning Algorithm
+import numpy as np
+
+# Input data
+X = np.array([
+    [2, 3],
+    [3, 4],
+    [4, 5],
+    [1, 1],
+    [2, 1],
+    [1, 2]
+])
+
+# Target outputs
+y = np.array([1, 1, 1, 0, 0, 0])
+
+# Initialize weights and bias
+weights = np.zeros(2)
+bias = 0
+learning_rate = 0.1
+
+# Perceptron learning (stops early once an epoch has no errors)
+for epoch in range(1, 101):
+    total_errors = 0
+    for i in range(len(X)):
+        z = np.dot(X[i], weights) + bias
+        prediction = 1 if z >= 0 else 0
+        error = y[i] - prediction
+        if error != 0:
+            weights = weights + learning_rate * error * X[i]
+            bias = bias + learning_rate * error
+            total_errors += 1
+    print(f"Epoch {epoch}: errors = {total_errors}")
+    if total_errors == 0:
+        break
+
+# Display trained parameters
+print("\nWeights:", weights)
+print("Bias:", bias)
+
+# Test the network
+test_data = np.array([
+    [5, 6],
+    [1, 1]
+])
+
+print("\nTesting")
+for point in test_data:
+    z = np.dot(point, weights) + bias
+    prediction = 1 if z >= 0 else 0
+    print(point, "=> Class", prediction)

numpysc_lib-1.1.1/numpysc_lib/__init__.py

@@ -0,0 +1,35 @@
+import os
+import sys
+
+def show_codes(filename: str = None):
+    """
+    Displays code included in this package.
+    - If filename is given (without .py), shows that file's code.
+    - If no filename is given, shows all .py files.
+    """
+    base_path = os.path.dirname(__file__)
+    files = [f for f in os.listdir(base_path) if f.endswith(".py") and f != "__init__.py"]
+
+    if filename:
+        file_path = os.path.join(base_path, f"{filename}.py")
+        if os.path.exists(file_path):
+            print(f"\n=== Showing {filename}.py ===\n")
+            with open(file_path, "r", encoding="utf-8") as f:
+                print(f.read())
+        else:
+            print(f"\n❌ File '{filename}.py' not found in this package.\n")
+            print("Available files:")
+            for f in files:
+                print("•", f.replace(".py", ""))
+    else:
+        print("\nAll practical codes:\n")
+        for f in files:
+            print(f"\n=== {f} ===\n")
+            with open(os.path.join(base_path, f), "r", encoding="utf-8") as file:
+                print(file.read())
+
+
+def main():
+    """Command-line entry point: soft-computing [filename]"""
+    filename = " ".join(sys.argv[1:]) or None
+    show_codes(filename)

numpysc_lib-1.1.1/numpysc_lib.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: numpysc-lib
+Version: 1.1.1
+Summary: Soft Computing Library
+Home-page: 
+Author: andhrew
+Author-email: xyz@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Soft Computing Library (`numpysc-lib`)
+
+A Python package that stores practical programs for **Soft Computing & Neural Networks** (Simple Neural Networks, Sigmoidal Functions, McCulloch-Pitts, Hebb Rule, Backpropagation, Fuzzy Sets, Perceptron) and prints their source code on demand, from Python or the terminal.
+
+Install it once with `pip`, then view any practical code on any machine without copying files around.
+
+---
+
+## Practicals Included
+
+| Practical | Topic / Description |
+|---|---|
+| `1A-Simple-Neural-Network` | Design a Simple Neural Network (SNN) with Ramp activation |
+| `1B-Sigmoidal-Functions` | Binary and Bipolar Sigmoidal Activation Functions |
+| `2A-McCulloch-Pitts Neural Network` | ANDNOT function using McCulloch-Pitts Neuron |
+| `2B-XOR function using McCulloch-Pitts Neural Network` | XOR function using McCulloch-Pitts Network |
+| `3-AND Hebb Rule Network` | AND function with Hebbian learning rule (bipolar inputs) |
+| `4-Back Propagation Problem` | Single-step forward & backward error propagation |
+| `5-Error Back Propagation` | Multi-epoch Error Backpropagation Training |
+| `6-Identity Operators` | Identity and Membership Operators in Python |
+| `7-Fuzzy` | Fuzzy Set Operations (Union, Intersection, Complement, Algebraic/Bounded Sum & Diff) |
+| `8-Perceptron` | Perceptron Learning Algorithm for Linear Classification |
+
+---
+
+## Step 1: Install
+
+```bash
+pip install numpysc-lib
+```
+
+To update to the latest version:
+
+```bash
+pip install --upgrade numpysc-lib
+```
+
+Requires Python 3.6 or newer.
+
+---
+
+## Step 2: View the programs
+
+### Option A: From the terminal
+
+Show all practicals:
+
+```bash
+numpysc
+# or
+numpysc-lib
+```
+
+Show a single practical (type the name or partial name):
+
+```bash
+numpysc "1A-Simple-Neural-Network"
+numpysc "7-Fuzzy"
+numpysc "8-Perceptron"
+```
+
+### Option B: From Python
+
+```python
+import numpysc_lib
+
+numpysc_lib.show_codes()                           # Show all practicals
+numpysc_lib.show_codes("7-Fuzzy")                  # Show specific practical
+numpysc_lib.show_codes("1A-Simple-Neural-Network") # Show specific practical
+```
+
+### Option C: In Google Colab or Jupyter
+
+```python
+!pip install numpysc-lib
+import numpysc_lib
+numpysc_lib.show_codes("8-Perceptron")
+```
+
+---
+
+## Publishing a new version (for maintainers)
+
+1. Make any additions or updates in the `numpysc_lib/` folder.
+2. Increment `version` in `setup.py` (e.g. `1.1.2`).
+3. Clean old builds:
+   ```bash
+   rm -rf dist build *.egg-info
+   ```
+4. Build:
+   ```bash
+   python3 -m build
+   ```
+5. Check and Upload to PyPI:
+   ```bash
+   python3 -m twine upload dist/*
+   ```
+
+---
+
+## License
+
+MIT. See [LICENSE](LICENSE).

numpysc_lib-1.1.1/numpysc_lib.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+numpysc_lib/1A-Simple-Neural-Network.py
+numpysc_lib/1B-Sigmoidal-Functions.py
+numpysc_lib/2A-McCulloch-Pitts Neural Network.py
+numpysc_lib/2B-XOR function using McCulloch-Pitts Neural Network.py
+numpysc_lib/3-AND Hebb Rule Network.py
+numpysc_lib/4-Back Propagation Problem.py
+numpysc_lib/5-Error Back Propagation.py
+numpysc_lib/6-Identity Operators.py
+numpysc_lib/7-Fuzzy.py
+numpysc_lib/8-Perceptron.py
+numpysc_lib/__init__.py
+numpysc_lib.egg-info/PKG-INFO
+numpysc_lib.egg-info/SOURCES.txt
+numpysc_lib.egg-info/dependency_links.txt
+numpysc_lib.egg-info/entry_points.txt
+numpysc_lib.egg-info/top_level.txt

numpysc_lib-1.1.1/numpysc_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

numpysc_lib-1.1.1/numpysc_lib.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+numpysc = numpysc_lib:main
+numpysc-lib = numpysc_lib:main

numpysc_lib-1.1.1/numpysc_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+numpysc_lib

numpysc_lib-1.1.1/setup.cfg

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

numpysc_lib-1.1.1/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+import io
+import os
+
+def read(fname):
+    return io.open(os.path.join(os.path.dirname(__file__), fname), encoding="utf-8").read()
+
+setup(
+    name="numpysc-lib",  # must be unique on PyPI
+    version="1.1.1",
+    author="andhrew",
+    author_email="xyz@gmail.com",
+    description="Soft Computing Library",
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    url="",  # optional
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[],
+    entry_points={
+        "console_scripts": [
+            "numpysc=numpysc_lib:main",
+            "numpysc-lib=numpysc_lib:main",
+        ],
+    },
+    license="MIT",  # ✅ SPDX-compliant license declaration
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)