first commit

README.md

@@ -1,12 +1,51 @@
 ---
-title: Znum Mcdm
-emoji: 🏃
+title: Z-Number MCDM Calculator
+emoji: 🧮
 colorFrom: blue
-colorTo: yellow
-sdk: docker
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
 license: mit
-short_description: Get the best alternative from your z-number decision matrix
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Z-Number MCDM Calculator
+
+A web application for Multi-Criteria Decision Making (MCDM) using Z-numbers with **TOPSIS** and **PROMETHEE** methods.
+
+## What are Z-Numbers?
+
+A Z-number is a fuzzy number with two components:
+- **A part**: The restriction on values (trapezoidal fuzzy number)
+- **B part**: The reliability/confidence of the information (values between 0 and 1)
+
+## Supported Methods
+
+### TOPSIS
+Technique for Order of Preference by Similarity to Ideal Solution. Ranks alternatives based on their distance from the ideal best and worst solutions.
+
+### PROMETHEE
+Preference Ranking Organization Method for Enrichment Evaluation. Uses pairwise preference comparisons and outranking flows.
+
+## Excel File Format
+
+Your Excel file should have this structure:
+
+| Row | Column A | Criterion 1 (8 cols) | Criterion 2 (8 cols) | ... |
+|-----|----------|---------------------|---------------------|-----|
+| 1   | W        | Weight Z-number     | Weight Z-number     | ... |
+| 2   | A1       | Alternative 1 values| Alternative 1 values| ... |
+| 3   | A2       | Alternative 2 values| Alternative 2 values| ... |
+| ... | ...      | ...                 | ...                 | ... |
+| N   | T        | B or C              | B or C              | ... |
+
+Each Z-number uses 8 consecutive columns:
+- First 4: A part (A₁ ≤ A₂ ≤ A₃ ≤ A₄)
+- Last 4: B part (B₁ ≤ B₂ ≤ B₃ ≤ B₄, values 0-1)
+
+Criteria types: **B** = Benefit, **C** = Cost
+
+## Powered by
+
+[znum](https://github.com/maganuriyev/znum) - Python library for Z-number arithmetic and MCDM

app.py

@@ -0,0 +1,305 @@
+"""
+Z-Number MCDM Web Application
+Multi-Criteria Decision Making with TOPSIS and PROMETHEE methods
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import copy
+from znum import Znum, Topsis, Promethee, Beast
+
+
+def parse_excel_to_table(df: pd.DataFrame):
+    """
+    Parse Excel DataFrame to MCDM table format.
+    
+    Expected format:
+    - Row 1: Weights (label 'W' in first column)
+    - Rows 2 to N-1: Alternatives (labels 'A1', 'A2', etc.)
+    - Row N: Criteria types ('B' for Benefit, 'C' for Cost)
+    
+    Each Z-number uses 8 columns: A1, A2, A3, A4, B1, B2, B3, B4
+    """
+    ZNUM_SIZE = 8
+    
+    rows = df.values.tolist()
+    
+    def parse_row(row):
+        """Parse a row into list of Znum objects."""
+        znums = []
+        # Skip the first column (label) and filter out NaN values
+        values = [float(v) for v in row[1:] if pd.notna(v) and v != '']
+        
+        for i in range(0, len(values), ZNUM_SIZE):
+            if i + ZNUM_SIZE <= len(values):
+                znum_vals = values[i:i + ZNUM_SIZE]
+                half = ZNUM_SIZE // 2
+                znum = Znum(A=znum_vals[:half], B=znum_vals[half:])
+                znums.append(znum)
+        return znums
+    
+    def parse_types(row):
+        """Parse criteria types row."""
+        types = []
+        values = row[1:]
+        i = 0
+        while i < len(values):
+            val = values[i]
+            if pd.notna(val) and str(val).strip().upper() in ['B', 'C']:
+                types.append(str(val).strip().upper())
+            i += ZNUM_SIZE  # Skip to next criteria
+        return types
+    
+    # Parse weights (first row)
+    weights = parse_row(rows[0])
+    
+    # Parse alternatives (middle rows)
+    alternatives = []
+    for row in rows[1:-1]:
+        alt = parse_row(row)
+        if alt:  # Only add non-empty alternatives
+            alternatives.append(alt)
+    
+    # Parse criteria types (last row)
+    criteria_types = parse_types(rows[-1])
+    
+    # Validate
+    n_criteria = len(weights)
+    if not all(len(alt) == n_criteria for alt in alternatives):
+        raise ValueError(f"All alternatives must have {n_criteria} criteria (matching weights)")
+    
+    if len(criteria_types) != n_criteria:
+        raise ValueError(f"Number of criteria types ({len(criteria_types)}) must match number of criteria ({n_criteria})")
+    
+    # Build table: [weights, alt1, alt2, ..., altN, criteria_types]
+    table = [weights] + alternatives + [criteria_types]
+    
+    return table, len(alternatives), n_criteria
+
+
+def run_topsis(table, normalize_weights, distance_method):
+    """Run TOPSIS method and return results."""
+    table_copy = copy.deepcopy(table)
+    
+    dist_type = (Topsis.DistanceMethod.HELLINGER 
+                 if distance_method == "Hellinger" 
+                 else Topsis.DistanceMethod.SIMPLE)
+    
+    topsis = Topsis(table_copy, shouldNormalizeWeight=normalize_weights, distanceType=dist_type)
+    scores = topsis.solve()
+    
+    # Create results DataFrame
+    results = []
+    ranked_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)
+    
+    for rank, idx in enumerate(ranked_indices, 1):
+        results.append({
+            "Rank": rank,
+            "Alternative": f"A{idx + 1}",
+            "Closeness Coefficient": f"{scores[idx]:.6f}",
+            "Original Index": idx + 1
+        })
+    
+    return pd.DataFrame(results), scores
+
+
+def run_promethee(table, normalize_weights):
+    """Run PROMETHEE method and return results."""
+    table_copy = copy.deepcopy(table)
+    
+    promethee = Promethee(table_copy, shouldNormalizeWeight=normalize_weights)
+    sorted_results = promethee.solve()
+    
+    # Create results DataFrame
+    results = []
+    for rank, (idx, znum) in enumerate(sorted_results, 1):
+        # Calculate a score representation from the Znum
+        score = np.mean(znum.A)  # Use mean of A part as score indicator
+        results.append({
+            "Rank": rank,
+            "Alternative": f"A{idx + 1}",
+            "Net Flow Score": f"{score:.6f}",
+            "Original Index": idx + 1
+        })
+    
+    return pd.DataFrame(results), sorted_results
+
+
+def process_file(file, method, normalize_weights, distance_method):
+    """Main processing function."""
+    if file is None:
+        return None, "Please upload an Excel file."
+    
+    try:
+        # Read Excel file
+        df = pd.read_excel(file.name, header=None)
+        
+        # Parse to table format
+        table, n_alternatives, n_criteria = parse_excel_to_table(df)
+        
+        info = f"✅ Parsed successfully: {n_alternatives} alternatives, {n_criteria} criteria\n\n"
+        
+        # Run selected method
+        if method == "TOPSIS":
+            results_df, _ = run_topsis(table, normalize_weights, distance_method)
+            info += f"**Method:** TOPSIS ({distance_method} distance)\n"
+        else:  # PROMETHEE
+            results_df, _ = run_promethee(table, normalize_weights)
+            info += f"**Method:** PROMETHEE II\n"
+        
+        info += f"**Weight Normalization:** {'Enabled' if normalize_weights else 'Disabled'}\n\n"
+        info += f"### 🏆 Best Alternative: {results_df.iloc[0]['Alternative']}\n"
+        info += f"### 📉 Worst Alternative: {results_df.iloc[-1]['Alternative']}"
+        
+        return results_df, info
+        
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}\n\nPlease check your Excel file format."
+
+
+def create_sample_excel():
+    """Create a sample Excel file for download."""
+    # Sample data with 3 alternatives and 3 criteria
+    data = [
+        # Weights row
+        ['W', 0.2, 0.3, 0.4, 0.5, 0.1, 0.2, 0.3, 0.4,  # Criterion 1 weight
+             0.3, 0.4, 0.5, 0.6, 0.2, 0.3, 0.4, 0.5,  # Criterion 2 weight
+             0.1, 0.2, 0.3, 0.4, 0.05, 0.1, 0.15, 0.2],  # Criterion 3 weight
+        # Alternative 1
+        ['A1', 7, 8, 9, 10, 0.6, 0.7, 0.8, 0.9,  # A1, C1
+              5, 6, 7, 8, 0.5, 0.6, 0.7, 0.8,   # A1, C2
+              6, 7, 8, 9, 0.6, 0.65, 0.7, 0.75],  # A1, C3
+        # Alternative 2
+        ['A2', 4, 5, 6, 7, 0.4, 0.5, 0.6, 0.7,  # A2, C1
+              8, 9, 10, 11, 0.7, 0.75, 0.8, 0.85,  # A2, C2
+              3, 4, 5, 6, 0.3, 0.4, 0.5, 0.6],  # A2, C3
+        # Alternative 3
+        ['A3', 6, 7, 8, 9, 0.5, 0.6, 0.7, 0.8,  # A3, C1
+              6, 7, 8, 9, 0.55, 0.65, 0.75, 0.85,  # A3, C2
+              7, 8, 9, 10, 0.6, 0.7, 0.8, 0.9],  # A3, C3
+        # Criteria types
+        ['T', 'B', '', '', '', '', '', '', '',  # Criterion 1: Benefit
+             'B', '', '', '', '', '', '', '',   # Criterion 2: Benefit
+             'C', '', '', '', '', '', '', ''],  # Criterion 3: Cost
+    ]
+    
+    df = pd.DataFrame(data)
+    
+    # Save to file
+    filepath = "/tmp/sample_mcdm_template.xlsx"
+    df.to_excel(filepath, index=False, header=False)
+    
+    return filepath
+
+
+# Create Gradio interface
+with gr.Blocks(title="Z-Number MCDM Calculator", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎯 Z-Number MCDM Calculator
+    ## Multi-Criteria Decision Making with TOPSIS & PROMETHEE
+    
+    Upload your decision matrix in Excel format and get instant rankings!
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📁 Input")
+            
+            file_input = gr.File(
+                label="Upload Excel File (.xlsx)",
+                file_types=[".xlsx", ".xls"],
+                type="filepath"
+            )
+            
+            method = gr.Radio(
+                choices=["TOPSIS", "PROMETHEE"],
+                value="TOPSIS",
+                label="Select Method"
+            )
+            
+            normalize_weights = gr.Checkbox(
+                value=True,
+                label="Normalize Weights"
+            )
+            
+            distance_method = gr.Radio(
+                choices=["Hellinger", "Simple"],
+                value="Hellinger",
+                label="Distance Method (TOPSIS only)",
+                visible=True
+            )
+            
+            submit_btn = gr.Button("🚀 Calculate Rankings", variant="primary")
+            
+            sample_btn = gr.Button("📥 Download Sample Template", variant="secondary")
+            sample_file = gr.File(label="Sample Template", visible=False)
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Results")
+            info_output = gr.Markdown()
+            results_output = gr.DataFrame(label="Rankings")
+    
+    gr.Markdown("""
+    ---
+    ## 📋 Excel File Format
+    
+    Your Excel file should follow this structure:
+    
+    | Row | Column A | Columns B-I (Criterion 1) | Columns J-Q (Criterion 2) | ... |
+    |-----|----------|---------------------------|---------------------------|-----|
+    | 1   | W        | A₁ A₂ A₃ A₄ B₁ B₂ B₃ B₄   | A₁ A₂ A₃ A₄ B₁ B₂ B₃ B₄   | ... |
+    | 2   | A1       | A₁ A₂ A₃ A₄ B₁ B₂ B₃ B₄   | A₁ A₂ A₃ A₄ B₁ B₂ B₃ B₄   | ... |
+    | 3   | A2       | A₁ A₂ A₃ A₄ B₁ B₂ B₃ B₄   | A₁ A₂ A₃ A₄ B₁ B₂ B₃ B₄   | ... |
+    | ... | ...      | ...                       | ...                       | ... |
+    | N   | T        | B or C                    | B or C                    | ... |
+    
+    ### Z-Number Structure (8 values per criterion):
+    - **A part** (4 values): `A₁ ≤ A₂ ≤ A₃ ≤ A₄` — The fuzzy restriction on values
+    - **B part** (4 values): `B₁ ≤ B₂ ≤ B₃ ≤ B₄` — The reliability/confidence (values between 0 and 1)
+    
+    ### Criteria Types (last row):
+    - **B** = Benefit (higher is better)
+    - **C** = Cost (lower is better)
+    
+    ### Example Z-Number:
+    `7, 8, 9, 10, 0.6, 0.7, 0.8, 0.9` means:
+    - A = [7, 8, 9, 10] (trapezoidal fuzzy number)
+    - B = [0.6, 0.7, 0.8, 0.9] (reliability)
+    
+    ---
+    ## 🔬 Methods
+    
+    **TOPSIS** (Technique for Order of Preference by Similarity to Ideal Solution):
+    - Ranks alternatives based on distance from ideal best and worst solutions
+    - Distance methods: Hellinger (recommended) or Simple
+    
+    **PROMETHEE** (Preference Ranking Organization Method for Enrichment Evaluation):
+    - Ranks alternatives based on pairwise preference comparisons
+    - Uses outranking flows to determine final ranking
+    
+    ---
+    *Powered by [znum](https://github.com/maganuriyev/znum) library*
+    """)
+    
+    # Event handlers
+    def toggle_distance_visibility(method):
+        return gr.update(visible=(method == "TOPSIS"))
+    
+    method.change(toggle_distance_visibility, inputs=[method], outputs=[distance_method])
+    
+    submit_btn.click(
+        process_file,
+        inputs=[file_input, method, normalize_weights, distance_method],
+        outputs=[results_output, info_output]
+    )
+    
+    def download_sample():
+        filepath = create_sample_excel()
+        return gr.update(value=filepath, visible=True)
+    
+    sample_btn.click(download_sample, outputs=[sample_file])
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+pandas>=2.0.0
+numpy>=1.24.0
+openpyxl>=3.1.0
+znum>=0.5.0
+scipy>=1.10.0