#include <iostream> #include <vector> #include <st...

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <algorithm>
#include <cctype>
#include <sstream>
#include <unordered_map>
#include <iomanip>
#include <cmath>
#include <memory>
#include <queue>
#include <unordered_set>
using namespace std;

/**************************************************************************************************

•                                      CONSTANTS
  

**************************************************************************************************/
static constexpr double DEFAULT_DIODE_DROP = 0.7; // ولتاژ افت دیود ایده‌آل (۷۰۰ mV)
static constexpr double SMALL_RESISTANCE_R = 1e-3; // مقاومت خیلی کوچک (1 mΩ) برای دیود/سلف در DC
static constexpr double EPS = 1e-12; // برای تشخیص تکین‌بودن ماتریس

/**************************************************************************************************

•                                  UTILITY FUNCTIONS
  

**************************************************************************************************/

// tiny helpers – put in a common header or anonymous namespace
static bool startsWith(const string& s, const string& prefix) { return s.rfind(prefix,0)==0; }
static string extractNode(const string& var) { auto l=var.find('('); auto r=var.find(')'); return var.substr(l+1,r-l-1); }
static string extractElement(const string& var){ auto l=var.find('('); auto r=var.find(')'); return var.substr(l+1,r-l-1); }
static vector<string> tokenize(const string &line) {
vector<string> tokens;
istringstream iss(line);
string word;
while (iss >> word) {
tokens.push_back(word);
}
return tokens;
}
// تابع تبدیل رشته به حروف کوچک
string toLower(const string& s) {
string result = s;
transform(result.begin(), result.end(), result.begin(), ::tolower);
return result;
}

// تابع بررسی وجود فایل
bool fileExists(const string& filename) {
ifstream file(filename);
return file.good();
}

// تابع نمایش محتوای فایل شماتیک
void showSchematicContent(const string& filename) {
ifstream file(filename);
if (!file) {
cout << "Error: Could not open file " << filename << endl;
return;
}

text
cout << filename << ":" << endl;
string line;
while (getline(file, line)) {
    cout << line << endl;
}
file.close();

}

// تابع اصلی منوی نمایش شماتیک‌ها
void showExistingSchematicsMenu() {
vector<string> schematics = {
"draft1.txt",
"draft2.txt",
"draft3.txt",
"elecphase1.txt"
};

text
while (true) {
    cout << "-choose existing schematic:" << endl;
    for (size_t i = 0; i < schematics.size(); i++) {
        cout << i+1 << "-" << schematics[i] << endl;
    }

    string input;
    cout << ">>> ";
    getline(cin, input);

    // خروج از منو اگر کاربر return وارد کند
    if (toLower(input) == "return") {
        break;
    }

    // بررسی ورودی جدید NewFile
    if (input.size() > 8 && toLower(input.substr(0, 8)) == "newfile ") {
        string filePath = input.substr(8);
        if (fileExists(filePath)) {
            showSchematicContent(filePath);
        } else {
            cout << "Error: File not found" << endl;
        }
        continue;
    }

    // بررسی ورودی عددی
    try {
        int choice = stoi(input);
        if (choice >= 1 && choice <= static_cast<int>(schematics.size())) {
            showSchematicContent(schematics[choice-1]);
        } else {
            cout << "-Error : Inappropriate input" << endl;
        }
    } catch (...) {
        cout << "-Error : Inappropriate input" << endl;
    }
}

}
/**

• iequals:
• مقایسهٔ دو رشته به صورت case-insensitive.
  */
  static bool iequals(const string &a, const string &b) {
  if (a.size() != b.size()) return false;
  for (size_t i = 0; i < a.size(); i++) {
  if (tolower(a[i]) != tolower(b[i])) return false;
  }
  return true;
  }

/**

• istarts_with:
• بررسی می‌کند آیا رشته s با prefix به صورت case-insensitive شروع می‌شود یا خیر.
  */
  static bool istarts_with(const string &s, const string &prefix) {
  if (s.size() < prefix.size()) return false;
  for (size_t i = 0; i < prefix.size(); i++) {
  if (tolower(s[i]) != tolower(prefix[i])) return false;
  }
  return true;
  }

/**

• toDouble:
• تبدیل رشته s به double؛ در صورت ناتوانی در تبدیل، runtime_error پرتاب می‌کند.
  */
  static double toDouble(const string &s) {
  string str = s;
  for (auto &c : str) c = tolower(c); // make lowercase

double multiplier = 1.0;

text
if (str.size() >= 3 && str.substr(str.size() - 3) == "meg") {
    multiplier = 1e6;
    str = str.substr(0, str.size() - 3);
} else if (!str.empty() && str.back() == 'g') {
    multiplier = 1e9;
    str.pop_back();
} else if (!str.empty() && str.back() == 'k') {
    multiplier = 1e3;
    str.pop_back();
} else if (!str.empty() && str.back() == 'm') {
    multiplier = 1e-3;
    str.pop_back();
} else if (!str.empty() && str.back() == 'u') {
    multiplier = 1e-6;
    str.pop_back();
} else if (!str.empty() && str.back() == 'n') {
    multiplier = 1e-9;
    str.pop_back();
} else if (!str.empty() && str.back() == 'p') {
    multiplier = 1e-12;
    str.pop_back();
} else if (!str.empty() && str.back() == 'f') {
    multiplier = 1e-15;
    str.pop_back();
}

try {
    size_t idx;
    double base = stod(str, &idx);
    if (idx != str.size()) throw runtime_error("");
    return base * multiplier;
} catch (...) {
    throw runtime_error("Invalid numeric value: " + s);
}

}
/**

• parseSINOffset:
• اگر در خط ورودی، الگوی SIN(...) وجود داشته باشد، مقدار آفست (عدد اول داخل پرانتز) را استخراج می‌کند.
• در غیر این صورت مقدار NaN برمی‌گرداند.
  */
  static double parseSINOffset(const string &line) {
  string lower = line;
  for (auto &c : lower) c = tolower(c);
  size_t pos = lower.find("sin(");
  if (pos == string::npos) {
  return nan("");
  }
  // یافتن پرانتز باز و بسته
  size_t start = line.find('(', pos);
  size_t end = line.find(')', start);
  if (start == string::npos || end == string::npos || end <= start + 1) {
  throw runtime_error("Syntax error: malformed SIN() in line: " + line);
  }
  // استخراج متن داخل پرانتز
  string inside = line.substr(start + 1, end - start - 1);
  // جایگزینی کاما با فاصله تا بتوانیم با istringstream بخوانیم
  for (auto &c : inside) {
  if (c == ',') c = ' ';
  }
  istringstream iss(inside);
  string first;
  if (!(iss >> first)) {
  throw runtime_error("Syntax error: empty SIN() arguments in line: " + line);
  }
  return toDouble(first);
  }

/**************************************************************************************************

•                        NODE MAPPING (STRING → INTEGER)
  

**************************************************************************************************/
struct NodeMap {
unordered_map<string,int> name2idx;
vector<string> idx2name;

text
NodeMap() {
    // گره زمین با نام "0" معادل اندیس 0
    name2idx["0"] = 0;
    idx2name.push_back("0");
}

/**
 * getIdx:
 *   اگر نام گره ثبت‌شده باشد اندیس آن را برمی‌گرداند، در غیر این صورت یک اندیس جدید اختصاص می‌دهد.
 */
int getIdx(const string &nodeName) {
    if (name2idx.count(nodeName)) return name2idx[nodeName];
    int newIdx = (int)idx2name.size();
    name2idx[nodeName] = newIdx;
    idx2name.push_back(nodeName);
    return newIdx;
}

bool hasName(const string &nodeName) const {
    return name2idx.count(nodeName);
}

int count() const {
    return (int)idx2name.size();
}

/**
 * renameNode:
 *   نام گره oldName را به newName تغییر می‌دهد. اگر oldName وجود نداشته باشد یا newName
 *   تکراری باشد، خطا پرتاب می‌کند.
 */
void renameNode(const string &oldName, const string &newName) {
    if (!name2idx.count(oldName)) {
        throw runtime_error("Error: node '" + oldName + "' not found.");
    }
    if (name2idx.count(newName)) {
        throw runtime_error("Error: node name '" + newName + "' already exists.");
    }
    int idx = name2idx[oldName];
    name2idx.erase(oldName);
    name2idx[newName] = idx;
    idx2name[idx] = newName;
}

};

/**************************************************************************************************

•                              ELEMENT BASE CLASS
  

**************************************************************************************************/
class Element {
public:
enum Type { RES, CAP, IND, DIO, VS, IS, VCVS, CCCS, CCVS, VCCS };
Element(Type t, string nm, int n1, int n2)
: type(t), name(std::move(nm)), nPlus(n1), nMinus(n2) {}
virtual ~Element() = default;

text
Type       type;    // نوع المان
string     name;    // نام المان
int        nPlus;   // اندیس گره مثبت یا اول
int        nMinus;  // اندیس گره منفی یا دوم

/**
 * stamp:
 *   وظیفه دارد مهرگذاری المان در ماتریس A و بردار b را انجام دهد.
 *   nNode تعداد گره‌های غیر از زمین است و vsMap نگاشت نام منابع ولتاژ به اندیس آنهاست.
 */
virtual void stamp(vector<vector<double>> &A, vector<double> &b,int nNode, const unordered_map<string,int> &vsMap) const = 0;
virtual void stampTransient(std::vector<std::vector<double>>& /*A*/,
                            std::vector<double>&              /*b*/,
                            double                            /*dt*/,
                            std::unordered_map<std::string,double>& /*capVPrev*/,
                            std::unordered_map<std::string,double>& /*indIPrev*/,
                            int                               /*nNode*/,
                            const std::unordered_map<std::string,int>& /*vsMap*/) const
{
    /* empty – override in C & L */
}

};

/**************************************************************************************************

•                            CONCRETE ELEMENT CLASSES
  

**************************************************************************************************/
class Resistor : public Element {
public:
double R;
Resistor(string nm, int a, int b, double val)
: Element(Element::RES, std::move(nm), a, b), R(val) {
if (R <= 0.0) {
throw runtime_error("Error: Resistance must be > 0 (" + name + ").");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
double g = 1.0 / R;
int i = nPlus, j = nMinus;
if (i != 0) A[i-1][i-1] += g;
if (j != 0) A[j-1][j-1] += g;
if (i != 0 && j != 0) {
A[i-1][j-1] -= g;
A[j-1][i-1] -= g;
}
}
};

class Capacitor : public Element {
public:
double C;
Capacitor(string nm, int a, int b, double val)
: Element(Element::CAP, std::move(nm), a, b), C(val) {
if (C < 0.0) {
throw runtime_error("Error: Capacitance must be ≥ 0 (" + name + ").");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
// در DC مثل مدار باز → هیچ مهرگذاری انجام نمی‌شود.
}
void stampTransient(std::vector<std::vector<double>>& A,
std::vector<double>& b,
double dt,
std::unordered_mapstd::string,double& capVPrev,
std::unordered_mapstd::string,double& /indIPrev/,
int nNode,
const std::unordered_mapstd::string,int& /vsMap/) const override
{
double G = C / dt; // Norton conductance
double Vpr = capVPrev[name]; // V[n]
double Ieq = G * Vpr; // companion current source

text
    int i = nPlus, j = nMinus;
    if (i != 0) A[i-1][i-1] += G;
    if (j != 0) A[j-1][j-1] += G;
    if (i != 0 && j != 0) {
        A[i-1][j-1] -= G;
        A[j-1][i-1] -= G;
    }
    if (i != 0) b[i-1] +=  Ieq;
    if (j != 0) b[j-1] += -Ieq;
}

};

class Inductor : public Element {
public:
double L;
Inductor(string nm, int a, int b, double val)
: Element(Element::IND, std::move(nm), a, b), L(val) {
if (L < 0.0) {
throw runtime_error("Error: Inductance must be ≥ 0 (" + name + ").");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
// مدل‌سازی سلف در DC به کمک مقاومت کوچک سری
double g = 1.0 / SMALL_RESISTANCE_R;
int i = nPlus, j = nMinus;
if (i != 0) A[i-1][i-1] += g;
if (j != 0) A[j-1][j-1] += g;
if (i != 0 && j != 0) {
A[i-1][j-1] -= g;
A[j-1][i-1] -= g;
}
}
void stampTransient(std::vector<std::vector<double>>& A,
std::vector<double>& b,
double dt,
std::unordered_mapstd::string,double& /capVPrev/,
std::unordered_mapstd::string,double& indIPrev,
int nNode,
const std::unordered_mapstd::string,int& /vsMap/) const override
{
double G = dt / L; // Norton conductance (G = 1/R)
double Ipr = indIPrev[name]; // I[n]
// Ieq is simply previous current (Norton current source)
double Ieq = Ipr;

text
    int i = nPlus, j = nMinus;
    if (i != 0) A[i-1][i-1] += G;
    if (j != 0) A[j-1][j-1] += G;
    if (i != 0 && j != 0) {
        A[i-1][j-1] -= G;
        A[j-1][i-1] -= G;
    }
    if (i != 0) b[i-1] += -Ieq;    // sign is opposite of capacitor!
    if (j != 0) b[j-1] +=  Ieq;
}

};

class Diode : public Element {
public:
string model;
Diode(string nm, int a, int b, string mdl)
: Element(Element::DIO, std::move(nm), a, b), model(std::move(mdl)) {
if (!iequals(model, "D")) {
throw runtime_error("Error: Unsupported diode model (“" + model + "”) in " + name + ".");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> &vsMap) const override {
int i = nPlus, j = nMinus;

text
    // look up the extra row for this diode’s 0.7 V source
    auto it = vsMap.find(name);
    int vsIdx = it->second;
    int rowVS = nNode + vsIdx;
    double g = 1.0 / SMALL_RESISTANCE_R;

// —— stamp R_s between rowVS and node i (nPlus) ——
if (i != 0) {
A[rowVS][rowVS] += g;
A[i - 1][i - 1] += g;
A[rowVS][i - 1] -= g;
A[i - 1][rowVS] -= g;
}

// —— stamp R_s between rowVS and node j (nMinus) ——
if (j != 0) {
A[rowVS][rowVS] += g;
A[j - 1][j - 1] += g;
A[rowVS][j - 1] -= g;
A[j - 1][rowVS] -= g;
}

// —— now enforce the 0.7 V drop as before ——
if (i != 0) A[rowVS][i - 1] += +1.0;
if (j != 0) A[rowVS][j - 1] += -1.0;
b[rowVS] = DEFAULT_DIODE_DROP;
if (i != 0) A[i - 1][rowVS] += +1.0;
if (j != 0) A[j - 1][rowVS] += -1.0;
}

};

class VoltageSource : public Element {
public:
double Vdc;
VoltageSource(string nm, int a, int b, double val)
: Element(Element::VS, std::move(nm), a, b), Vdc(val) {
if (!(name.size()>0 && (name[0]=='V' || name[0]=='v'))) {
throw runtime_error("Error: Voltage source name must start with 'V': " + name);
}
}
void stamp(vector<vector<double>> &A,vector<double> &b,int nNode , const unordered_map<string,int> &vsMap) const override {
auto it = vsMap.find(name);
if (it == vsMap.end()) {
throw runtime_error("Error: VS index not found for " + name + ".");
}
int vsIndex = it->second;
int rowVS = nNode + vsIndex;
int i = nPlus, j = nMinus;
if (i != 0) A[rowVS][i-1] = +1.0;
if (j != 0) A[rowVS][j-1] = -1.0;
b[rowVS] = Vdc;
if (i != 0) A[i-1][rowVS] += +1.0;
if (j != 0) A[j-1][rowVS] += -1.0;
}
};

class CurrentSource : public Element {
public:
double I;
CurrentSource(string nm, int a, int b, double val)
: Element(Element::IS, std::move(nm), a, b), I(val) {
if (!(name.size()>0 && (name[0]=='I' || name[0]=='i'))) {
throw runtime_error("Error: Current source name must start with 'I': " + name);
}
}
void stamp(vector<vector<double>> & /A/,
vector<double> &b,
int /nNode/,
const unordered_map<string,int> & /vsMap/) const override {
int i = nPlus, j = nMinus;
if (i != 0) b[i-1] += -I;
if (j != 0) b[j-1] += +I;
}
};

class VCVS : public Element {
public:
int ctrlP, ctrlM;
double gain;
VCVS(string nm, int a, int b, int cp, int cm, double gv): Element(Element::VCVS, std::move(nm), a, b), ctrlP(cp), ctrlM(cm), gain(gv) {
if (!(name.size()>0 && (name[0]=='E' || name[0]=='e'))) {
throw runtime_error("Error: VCVS name must start with 'E': " + name);
}
}
void stamp(vector<vector<double>> &A,vector<double>&b,int nNode,const unordered_map<string,int> &vsMap) const override {
auto it = vsMap.find(name);
if (it == vsMap.end()) {
throw runtime_error("Error: VCVS index not found for " + name + ".");
}
int vsIndex = it->second;
int rowVS = nNode + vsIndex;
int i = nPlus, j = nMinus;
int cp = ctrlP, cm = ctrlM;
if (i != 0) A[rowVS][i-1] = +1.0;
if (j != 0) A[rowVS][j-1] = -1.0;
if (cp != 0) A[rowVS][cp-1] += -gain;
if (cm != 0) A[rowVS][cm-1] += +gain;
b[rowVS] = 0.0;
if (i != 0) A[i-1][rowVS] += +1.0;
if (j != 0) A[j-1][rowVS] += -1.0;
}
};

class CCCS : public Element {
public:
string ctrlVSname;
double gain;
CCCS(string nm, int a, int b, string cvs, double gv)
: Element(Element::CCCS, std::move(nm), a, b), ctrlVSname(std::move(cvs)), gain(gv) {
if (!(name.size()>0 && (name[0]=='F' || name[0]=='f'))) {
throw runtime_error("Error: CCCS name must start with 'F': " + name);
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> &vsMap) const override {
auto it = vsMap.find(ctrlVSname);
if (it == vsMap.end()) {
throw runtime_error("Error: controlling VS '" + ctrlVSname + "' not found for " + name + ".");
}
int ctrlIdx = it->second;
int colCtrl = nNode + ctrlIdx;
int i = nPlus, j = nMinus;
if (i != 0) A[i-1][colCtrl] += -gain;
if (j != 0) A[j-1][colCtrl] += +gain;
}
};

class CCVS : public Element {
public:
string ctrlVSname;
double gain;
CCVS(string nm, int a, int b, string cvs, double gv)
: Element(Element::CCVS, std::move(nm), a, b), ctrlVSname(std::move(cvs)), gain(gv) {
if (!(name.size()>0 && (name[0]=='H' || name[0]=='h'))) {
throw runtime_error("Error: CCVS name must start with 'H': " + name);
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> &vsMap) const override {
auto itSelf = vsMap.find(name);
if (itSelf == vsMap.end()) {
throw runtime_error("Error: CCVS index not found for " + name + ".");
}
int vsIndex = itSelf->second;
int rowVS = nNode + vsIndex;
auto itCtrl = vsMap.find(ctrlVSname);
if (itCtrl == vsMap.end()) {
throw runtime_error("Error: controlling VS '" + ctrlVSname + "' not found for " + name + ".");
}
int ctrlIdx = itCtrl->second;
int colCtrl = nNode + ctrlIdx;
int i = nPlus, j = nMinus;
if (i != 0) A[rowVS][i-1] = +1.0;
if (j != 0) A[rowVS][j-1] = -1.0;
A[rowVS][colCtrl] = -gain;
b[rowVS] = 0.0;
if (i != 0) A[i-1][rowVS] += +1.0;
if (j != 0) A[j-1][rowVS] += -1.0;
}
};

class VCCS : public Element {
public:
int ctrlP, ctrlM;
double gain;
VCCS(string nm, int a, int b, int cp, int cm, double gv)
: Element(Element::VCCS, std::move(nm), a, b), ctrlP(cp), ctrlM(cm), gain(gv) {
if (!(name.size()>0 && (name[0]=='G' || name[0]=='g'))) {
throw runtime_error("Error: VCCS name must start with 'G': " + name);
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
int i = nPlus, j = nMinus;
int cp = ctrlP, cm = ctrlM;
if (i != 0 && cp != 0) A[i-1][cp-1] += +gain;
if (i != 0 && cm != 0) A[i-1][cm-1] += -gain;
if (j != 0 && cp != 0) A[j-1][cp-1] += -gain;
if (j != 0 && cm != 0) A[j-1][cm-1] += +gain;
}
};

/**************************************************************************************************

•                       PRINT REQUEST STRUCTURE (Section 15)
  

**************************************************************************************************/
struct PrintRequest {
enum Mode { DC, TRAN } mode;
string sourceName; // نام منبع ولتاژ برای DC sweep
double startVal, endVal, step;
vector<string> variables; // لیستی از عبارت‌های V(<node>) یا I(<element>)
};

/**************************************************************************************************

•                          CIRCUIT CLASS: Holds elements & parsing
  

************************************************************************************************/
class Circuit {
public:
NodeMap nodes;
vector< unique_ptr<Element> > elements;
unordered_map<string,int> vsMap;
bool readingDone = false;
vector<PrintRequest> printRequests;
/
* parseLine:
* پارس یک خط از نت‌لیست و اعمال دستورهای متنی.
* پشتیبانی از:
* add R,C,L,D,V,I,E,F,H,G
* delete <elementName>
* .nodes
* .list <type>
* rename <oldNode> <newNode>
* .print DC ...
* .end
/
/ saved state for C & L (keys = element name) */
std::unordered_mapstd::string,double capVPrev;
std::unordered_mapstd::string,double indIPrev;
void parseLine(const string &line) {
char first = toupper(line[0]);
if (first == 'R' || first == 'C' || first == 'L' || first == 'D'||
first == 'V' || first == 'I' || first == 'E' || first == 'F' ||
first == 'H' || first == 'G') {
parseLine("add " + line);
return;
}
if (line.empty()) return;
vector<string> tok = tokenize(line);
if (tok.empty()) return;
string cmd = tok[0];

text
    // ===== دستور add =====
    if (istarts_with(cmd, "add")) {
        if (tok.size() < 2) {
            throw runtime_error("Syntax error: 'add' needs arguments.");
        }
        string elemName = tok[1];
        char c0 = toupper(elemName[0]);

        // اگر نوع V باشد و عبارت SIN در خط موجود باشد، آفست را استخراج کرده و
        // tok را به معادل DC بازسازی می‌کنیم:
        double sinOffset = nan("");
        if (c0 == 'V') {
            sinOffset = parseSINOffset(line);
            if (!isnan(sinOffset)) {
                // بازسازی tok به صورت: add elemName n+ n- DC <sinOffset>
                if (tok.size() < 4) {
                    throw runtime_error("Syntax error in SIN voltage source: " + line);
                }
                tok = { "add", elemName, tok[2], tok[3], "DC", to_string(sinOffset) };
            }
        }

        if (c0 == 'R') {
            // فرمت: add R<name> n+ n- <value>
            if (tok.size() != 5) {
                throw runtime_error("Syntax error in resistor definition: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            double val = toDouble(tok[4]);
            elements.emplace_back(new Resistor(elemName, n1, n2, val));
        }
        else if (c0 == 'C') {
            // فرمت: add C<name> n+ n- <value>
            if (tok.size() != 5) {
                throw runtime_error("Syntax error in capacitor definition: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            double val = toDouble(tok[4]);
            elements.emplace_back(new Capacitor(elemName, n1, n2, val));
        }
        else if (c0 == 'L') {
            // فرمت: add L<name> n+ n- <value>
            if (tok.size() != 5) {
                throw runtime_error("Syntax error in inductor definition: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            double val = toDouble(tok[4]);
            elements.emplace_back(new Inductor(elemName, n1, n2, val));
        }
        else if (c0 == 'D') {
            // فرمت: add D<name> n+ n- <model>
            if (tok.size() < 4 || tok.size() > 5) {
                throw runtime_error("Syntax error in diode definition: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            string mdl = (tok.size() == 5 ? tok[4] : "D");
            elements.emplace_back(new Diode(elemName, n1, n2, mdl));
        }
        else if (c0 == 'V') {
            // حالا tok به صورت: [ "add", elemName, n+, n-, "DC", val ] است
            if (tok.size() != 6 || !iequals(tok[4], "DC")) {
                throw runtime_error("Syntax error in voltage source: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            double val = toDouble(tok[5]);
            elements.emplace_back(new VoltageSource(elemName, n1, n2, val));
        }
        else if (c0 == 'I') {
            // فرمت: add I<name> n+ n- DC <value>
            if (tok.size() != 6 || !iequals(tok[4], "DC")) {
                throw runtime_error("Syntax error in current source: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            double val = toDouble(tok[5]);
            elements.emplace_back(new CurrentSource(elemName, n1, n2, val));
        }
        else if (c0 == 'E') {
            // فرمت: add E<name> n+ n- c+ c- <gain>
            if (tok.size() != 7) {
                throw runtime_error("Syntax error in VCVS: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            int cp = nodes.getIdx(tok[4]);
            int cm = nodes.getIdx(tok[5]);
            double g = toDouble(tok[6]);
            elements.emplace_back(new VCVS(elemName, n1, n2, cp, cm, g));
        }
        else if (c0 == 'F') {
            // فرمت: add F<name> n+ n- <ctrlVS> <gain>
            if (tok.size() != 6) {
                throw runtime_error("Syntax error in CCCS: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            string cvs = tok[4];
            double g = toDouble(tok[5]);
            elements.emplace_back(new CCCS(elemName, n1, n2, cvs, g));
        }
        else if (c0 == 'H') {
            // فرمت: add H<name> n+ n- <ctrlVS> <gain>
            if (tok.size() != 6) {
                throw runtime_error("Syntax error in CCVS: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            string cvs = tok[4];
            double g = toDouble(tok[5]);
            elements.emplace_back(new CCVS(elemName, n1, n2, cvs, g));
        }
        else if (c0 == 'G') {
            // فرمت: add G<name> n+ n- c+ c- <gain>
            if (tok.size() != 7) {
                throw runtime_error("Syntax error in VCCS: " + line);
            }
            int n1 = nodes.getIdx(tok[2]);
            int n2 = nodes.getIdx(tok[3]);
            int cp = nodes.getIdx(tok[4]);
            int cm = nodes.getIdx(tok[5]);
            double g = toDouble(tok[6]);
            elements.emplace_back(new VCCS(elemName, n1, n2, cp, cm, g));
        }
        else {
            throw runtime_error("Unknown element type in 'add': " + elemName);
        }
    }
        // ===== دستور delete =====
    else if (istarts_with(cmd, "delete")) {
        // فرمت: delete <elementName>
        if (tok.size() != 2) {
            throw runtime_error("Syntax error: 'delete' requires exactly one argument.");
        }
        string enm = tok[1];
        bool found = false;
        for (auto it = elements.begin(); it != elements.end(); ++it) {
            if (iequals((*it)->name, enm)) {
                elements.erase(it);
                found = true;
                break;
            }
        }
        if (!found) {
            throw runtime_error("Error: element '" + enm + "' not found.");
        }
    }
        // ===== دستور .nodes =====
    else if (iequals(cmd, ".nodes")) {
        printNodes();
    }
        // ===== دستور .list =====
    else if (iequals(cmd, ".list")) {
        if (tok.size() != 2) {
            throw runtime_error("Syntax error: '.list' requires exactly one type argument.");
        }
        printList(tok[1]);
    }
        // ===== دستور rename =====
    else if (iequals(cmd, "rename")) {
        if (tok.size() != 3) {
            throw runtime_error("Syntax error: 'rename' requires two arguments.");
        }
        nodes.renameNode(tok[1], tok[2]);
    }
        // ===== دستور .print =====  (بخش 15)
    else if (iequals(cmd, ".print")) {
        if (tok.size() < 7) {
            throw runtime_error("Syntax error in .print command: " + line);
        }
        PrintRequest pr;
        if (iequals(tok[0], ".print") && iequals(tok[1], "DC") && tok.size() >= 3 && tok.size() < 7) {
            pr.mode = PrintRequest::DC;
            pr.sourceName = "";      // منبع sweep وجود ندارد
            pr.startVal = 0;
            pr.endVal = 0;
            pr.step = 0;

            for (size_t i = 2; i < tok.size(); ++i) {
                pr.variables.push_back(tok[i]);
            }

            printRequests.push_back(move(pr));
            return;
        }
        if (iequals(tok[1], "DC")) {
            pr.mode = PrintRequest::DC;
            if (tok.size() >= 7) {
                pr.sourceName = tok[2];
                pr.startVal = toDouble(tok[3]);
                pr.endVal   = toDouble(tok[4]);
                pr.step     = toDouble(tok[5]);
                for (int i = 6; i < tok.size(); i++)
                    pr.variables.push_back(tok[i]);
            } else {
                // پشتیبانی از .print DC بدون sweep
                pr.sourceName = "";
                pr.startVal = pr.endVal = pr.step = 0;
                for (int i = 2; i < tok.size(); i++)
                    pr.variables.push_back(tok[i]);
            }
        }
        else if (iequals(tok[1], "TRAN")) {
            pr.mode  = PrintRequest::TRAN;
            pr.startVal = toDouble(tok[2]);   // tstep
            pr.endVal   = toDouble(tok[3]);   // tstop
            pr.step     = toDouble(tok[2]);   // store tstep again
            double tstart = toDouble(tok[4]); // often 0
            double tmax   = toDouble(tok[5]); // ignored for now
            // vars begin at tok[6]
            for (size_t i=6;i<tok.size();++i) pr.variables.push_back(tok[i]);
            pr.sourceName = "";              // not used in TRAN
        }
        else {
            throw runtime_error("Only DC .print is supported in this version: " + line);
        }
        printRequests.push_back(move(pr));
    }
        // ===== دستور .end =====
    else if (iequals(cmd, ".end")) {
        readingDone = true;
    }
    else {
        throw runtime_error("Unknown command: " + line);
    }
}

/**
 * solveDC:
 *   پس از دریافت دستور .end، ماتریس MNA را می‌سازد، حل می‌کند و نتایج را چاپ می‌کند.
 *   اگر دستورات .print وجود داشته باشد، به جای یک‌بار حل، برای هر PrintRequest حل مکرر اجرا می‌شود.
 */
void solveDC() {
    // 1) ساخت vsMap: نگاشت نام منابع ولتاژ (شامل دیود و منابع وابسته) به یک ایندکس
    vsMap.clear();
    int M = 0;
    for (const auto &e: elements) {
        if (e->type == Element::VS
            || e->type == Element::DIO
            || e->type == Element::VCVS
            || e->type == Element::CCVS) {
            vsMap[e->name] = M++;
        }
    }

    int totalNodes = nodes.count();       // شامل گره 0
    int nNode = totalNodes - 1;           // تعداد گره‌های واقعی (بدون گره زمین)
    int N = nNode + M;                    // ابعاد ماتریس A و بردار b

    // اگر هیچ دستور .print تعریف نشده، یک بار حل کن و چاپ کن
    if (printRequests.empty()) {
        bool hasSweep = false;
        for (const auto &pr: printRequests)
            if (pr.mode == PrintRequest::DC && !pr.sourceName.empty())
                hasSweep = true;
        if (!hasSweep) {
            vector<vector<double>> A(N, vector<double>(N, 0.0));
            vector<double> b(N, 0.0);
            for (const auto &e: elements) {
                e->stamp(A, b, nNode, vsMap);
            }
            vector<double> x = gaussianEliminate(A, b);
            for (const auto& pr : printRequests) {
                if (pr.mode != PrintRequest::DC || !pr.variables.size()) continue;
                cout << "\n--- Custom DC Output ---\n";
                for (const auto &var: pr.variables) {
                    if (istarts_with(var, "V(") && var.back() == ')') {
                        string nodeName = var.substr(2, var.size() - 3);
                        if (!nodes.hasName(nodeName)) {
                            cout << "V(" << nodeName << "): ERROR - Node not found\n";
                        } else {
                            int idx = nodes.name2idx.at(nodeName);
                            double Vnode = (idx == 0 ? 0.0 : x[idx - 1]);
                            cout << "V(" << nodeName << "): " << Vnode << " V\n";
                        }
                    }
                    else if (istarts_with(var, "I(") && var.back() == ')') {
                        string elemName = var.substr(2, var.size() - 3);
                        bool printed = false;
                        if (vsMap.count(elemName)) {
                            int vsIdx = vsMap.at(elemName);
                            double Ielem = x[nNode + vsIdx];
                            cout << "I(" << elemName << "): " << Ielem << " A\n";
                            printed = true;
                        } else {
                            for (const auto& e : elements) {
                                if (iequals(e->name, elemName)) {
                                    if (e->type == Element::RES) {
                                        auto* r = static_cast<Resistor*>(e.get());
                                        int np = r->nPlus, nm = r->nMinus;
                                        double Vp = (np == 0 ? 0.0 : x[np - 1]);
                                        double Vm = (nm == 0 ? 0.0 : x[nm - 1]);
                                        double Ires = (Vp - Vm) / r->R;
                                        cout << "I(" << elemName << "): " << Ires << " A\n";
                                        printed = true;
                                    } else if (e->type == Element::IS) {
                                        auto* isrc = static_cast<CurrentSource*>(e.get());
                                        cout << "I(" << elemName << "): " << isrc->I << " A\n";
                                        printed = true;
                                    }
                                    break;
                                }
                            }
                        }
                        if (!printed) {
                            cout << "I(" << elemName << "): ERROR - Element not found\n";
                        }
                    } else {
                        cout << var << ": ERROR - Invalid variable\n";
                    }
                }
                cout << "--- End Custom DC Output ---\n";
            }
            cout << fixed << setprecision(6);
            cout << "\n=== DC Operating-Point ===\n";
            for (int i = 1; i < totalNodes; i++) {
                cout << "Node " << nodes.idx2name[i]
                     << " (idx " << i << "): " << x[i - 1] << " V\n";
            }
            cout << "Node 0 (GND): 0.000000 V\n";
            for (const auto &p: vsMap) {
                const string &nm = p.first;
                int idx = p.second;
                double Iv = x[nNode + idx];
                cout << "I(" << nm << "): " << Iv << " A\n";
            }
            cout << "=== End of Results ===\n";
            return;
        }
            // 2) برای هر دستور .print DC، یک loop از startVal تا endVal اجرا کن (شامل هر دو) با گام step
        else {
            for (const auto &pr: printRequests)
                if (pr.mode == PrintRequest::TRAN)
                    simulateTRAN(pr.step, pr.endVal, pr.startVal, pr.variables);
                else if (pr.mode == PrintRequest::DC) {
                    // چک کن که منبع ولتاژ وجود دارد
                    const string &src = pr.sourceName;
                    bool foundVS = false;
                    VoltageSource *vsPtr = nullptr;
                    for (auto &e: elements) {
                        if (iequals(e->name, src) && e->type == Element::VS) {
                            vsPtr = static_cast<VoltageSource *>(e.get());
                            foundVS = true;
                            break;
                        }
                    }
                    if (!foundVS) {
                        cout << "ERROR: Voltage source '" << src << "' not found in circuit\n";
                        continue;
                    }
                    // چاپ عنوان جدول
                    cout << "\n=== DC Sweep: Source " << src
                         << " from " << pr.startVal << " to " << pr.endVal
                         << " step " << pr.step << " ===\n";
                    // چاپ هدر: نام منبع، سپس هر متغیر
                    cout << src;
                    for (const auto &var: pr.variables) {
                        cout << "\t" << var;
                    }
                    cout << "\n";

                    // حلقهٔ Sweep
                    for (double Vsrc = pr.startVal; Vsrc <= pr.endVal + EPS; Vsrc += pr.step) {
                        // تنظیم مقدار منبع ولتاژ روی Vsrc
                        vsPtr->Vdc = Vsrc;

                        // ساختن ماتریس و بردار برای هر تکرار
                        vector<vector<double>> A(N, vector<double>(N, 0.0));
                        vector<double> b(N, 0.0);
                        for (const auto &e: elements) {
                            e->stamp(A, b, nNode, vsMap);
                        }
                        vector<double> x = gaussianEliminate(A, b);

                        // چاپ خط: مقدار منبع، سپس مقادیر متغیرهای خواسته‌شده
                        cout << fixed << setprecision(6) << Vsrc;
                        for (const auto &var: pr.variables) {
                            // متغیرهای ولتاژ: V(node)
                            if (istarts_with(var, "V(") && var.back() == ')') {
                                string nodeName = var.substr(2, var.size() - 3);
                                if (!nodes.hasName(nodeName)) {
                                    cout << "\t" << "ERROR: Node " << nodeName << " not found";
                                } else {
                                    int idx = nodes.name2idx.at(nodeName);
                                    double Vnode = (idx == 0 ? 0.0 : x[idx - 1]);
                                    cout << "\t" << Vnode;
                                }
                            }
                                // متغیرهای جریان: I(element)
                            else if (istarts_with(var, "I(") && var.back() == ')') {
                                string elemName = var.substr(2, var.size() - 3);
                                bool printed = false;
                                // 1) اگر المان در vsMap (منابع ولتاژ/دیود/VCVS/CCVS) بود:
                                if (vsMap.count(elemName)) {
                                    int vsIdx = vsMap.at(elemName);
                                    double Ielem = x[nNode + vsIdx];
                                    cout << "\t" << Ielem;
                                    printed = true;
                                } else {
                                    // 2) جست‌وجو در لیست المان‌ها برای مقاومت یا منبع جریان
                                    for (const auto &e: elements) {
                                        if (iequals(e->name, elemName)) {
                                            if (e->type == Element::RES) {
                                                // جریان مقاومت = (V(nPlus) - V(nMinus)) / R
                                                Resistor *rptr = static_cast<Resistor *>(e.get());
                                                int np = rptr->nPlus, nm = rptr->nMinus;
                                                double Vp = (np == 0 ? 0.0 : x[np - 1]);
                                                double Vm = (nm == 0 ? 0.0 : x[nm - 1]);
                                                double Ires = (Vp - Vm) / rptr->R;
                                                cout << "\t" << Ires;
                                                printed = true;
                                            } else if (e->type == Element::IS) {
                                                // جریان منبع جریان مستقل: همان مقدار I
                                                CurrentSource *iptr = static_cast<CurrentSource *>(e.get());
                                                cout << "\t" << iptr->I;
                                                printed = true;
                                            }
                                            // برای سایر انواع (مثلاً خازن/سلف) در DC منطق ساده نمی‌توان جریان را تعریف کرد
                                            break;
                                        }
                                    }
                                }
                                if (!printed) {
                                    cout << "\t" << "ERROR: Element " << elemName << " not found";
                                }
                            } else {
                                cout << "\t" << "ERROR: Invalid variable '" << var << "'";
                            }
                        }
                        cout << "\n";
                    }
                    cout << "=== End of DC Sweep for " << src << " ===\n";
                }
        }
    }
}
void simulateTRAN(double tstep, double tstop, double tstart,
                  const std::vector<std::string>& vars)
{
    // --- prepare constant info ---
    vsMap.clear();
    int M = 0;
    for (const auto& e : elements)
        if (e->type == Element::VS  || e->type == Element::DIO
            || e->type == Element::VCVS|| e->type == Element::CCVS)
            vsMap[e->name] = M++;

    int totalNodes = nodes.count();
    int nNode      = totalNodes - 1;
    int N          = nNode + M;

    /* initialise past state to zero */
    capVPrev.clear();  indIPrev.clear();
    for (const auto& e : elements)
        if (e->type == Element::CAP) capVPrev[e->name] = 0.0;
        else if (e->type == Element::IND) indIPrev[e->name] = 0.0;

    std::cout << "Time";
    for (const auto& v : vars) std::cout << '\t' << v;
    std::cout << '\n' << std::fixed << std::setprecision(6);

    // --- main time-loop ---
    for (double t = tstart; t <= tstop + EPS; t += tstep) {
        std::vector<std::vector<double>> A(N, std::vector<double>(N, 0.0));
        std::vector<double>              b(N, 0.0);

        // stamp every element (DC + transient part)
        for (const auto& e : elements) {
            e->stamp(A, b, nNode, vsMap);                              // DC part
            e->stampTransient(A, b, tstep, capVPrev, indIPrev,
                              nNode, vsMap);                           // dynamic part
        }

        std::vector<double> x = gaussianEliminate(A, b);

        // ---- print requested variables ----
        std::cout << t;
        for (const auto& var : vars) {
            if (startsWith(var, "V(") && var.back()==')') {             // node voltage
                std::string node = extractNode(var);
                double v = (node=="0") ? 0.0 : x[nodes.name2idx[node]-1];
                std::cout << '\t' << v;
            }
            else if (startsWith(var, "I(") && var.back()==')') {        // element current
                std::string el = extractElement(var);
                double I = 0.0;
                if (vsMap.count(el))             // any device with extra MNA row
                    I = x[nNode + vsMap[el]];
                else {
                    /* quick support for R, C, L, I */
                    for (const auto& e : elements)
                        if (iequals(e->name, el)) {
                            if (e->type == Element::RES) {
                                auto* r = static_cast<Resistor*>(e.get());
                                double vp = (r->nPlus==0?0.0:x[r->nPlus-1]);
                                double vn = (r->nMinus==0?0.0:x[r->nMinus-1]);
                                I = (vp - vn)/r->R;
                            }
                            else if (e->type == Element::CAP){
                                auto* c = static_cast<Capacitor*>(e.get());
                                I = c->C / tstep * capVPrev[el]; }// approximate
                            else if (e->type == Element::IND) I = indIPrev[el];
                            else if (e->type == Element::IS)  I = static_cast<CurrentSource*>(e.get())->I;
                            break;
                        }
                }
                std::cout << '\t' << I;
            }
            else std::cout << "\tERR";
        }
        std::cout << '\n';
        for (const auto& e : elements) {
            if (e->type == Element::CAP) {
                auto* c = static_cast<Capacitor*>(e.get());
                double vp = (c->nPlus==0?0.0:x[c->nPlus-1]);
                double vn = (c->nMinus==0?0.0:x[c->nMinus-1]);
                capVPrev[c->name] = vp - vn;                         // V[n+1]
            } else if (e->type == Element::IND) {
                auto* l = static_cast<Inductor*>(e.get());
                double vp = (l->nPlus==0?0.0:x[l->nPlus-1]);
                double vn = (l->nMinus==0?0.0:x[l->nMinus-1]);
                double vL = vp - vn;
                indIPrev[l->name] += (tstep / l->L) * vL;            // I[n+1] = I[n] + (dt/L)*v
            }
        }
    }
}

public:
/**
* printNodes:
* چاپ لیست گره‌ها و اندیس‌هایشان.
*/
bool hasGroundNode() const {
return nodes.hasName("0");
}
bool isConnectedCircuit() const {
int n = nodes.count();
if (n <= 1) return true;
vector<vector<int>> adj(n);
for (const auto& e : elements) {
adj[e->nPlus].push_back(e->nMinus);
adj[e->nMinus].push_back(e->nPlus);
}
vector<bool> visited(n, false);
queue<int> q;
q.push(0);
visited[0] = true;
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : adj[u]) {
if (!visited[v]) {
visited[v] = true;
q.push(v);
}
}
}
return all_of(visited.begin(), visited.end(), [](bool v) { return v; });
}
bool hasDuplicateNames() const {
unordered_set<string> names;
for (const auto& e : elements) {
string up = e->name;
transform(up.begin(), up.end(), up.begin(), ::toupper);
if (!names.insert(up).second) return true;
}
return false;
}
void printNodes() const {
cout << "\n-- Node List --\n";
for (int i = 0; i < nodes.count(); i++) {
cout << "Index " << i << " : " << nodes.idx2name[i] << "\n";
}
cout << "-- End Node List --\n";
}
void printList(const string &typ) const {
char t0 = toupper(typ[0]);
cout << "\n-- Elements of type " << typ << " --\n";
for (const auto &e : elements) {
bool match = false;
switch (t0) {
case 'R': match = (e->type == Element::RES); break;
case 'C': match = (e->type == Element::CAP); break;
case 'L': match = (e->type == Element::IND); break;
case 'D': match = (e->type == Element::DIO); break;
case 'V': match = (e->type == Element::VS); break;
case 'I': match = (e->type == Element::IS); break;
case 'E': match = (e->type == Element::VCVS); break;
case 'F': match = (e->type == Element::CCCS); break;
case 'H': match = (e->type == Element::CCVS); break;
case 'G': match = (e->type == Element::VCCS); break;
default:
throw runtime_error("Unknown element type for '.list': " + typ);
}
if (match) {
cout << e->name << " : ";
cout << "nodes[" << nodes.idx2name[e->nPlus] << ", "
<< nodes.idx2name[e->nMinus] << "]\n";
}
}
cout << "-- End List --\n";
}

text
/**
 * gaussianEliminate:
 *   حل دستگاه خطی A·x = b با روش حذف گاوس و قطبیابی جزئی.
 *   اگر ماتریس تکین باشد، runtime_error پرتاب می‌کند.
 */
vector<double> gaussianEliminate(vector<vector<double>> &A, vector<double> &b) {
    int n = (int)b.size();
    for (int k = 0; k < n; k++) {
        int piv = k;
        for (int i = k+1; i < n; i++) {
            if (fabs(A[i][k]) > fabs(A[piv][k])) piv = i;
        }
        if (fabs(A[piv][k]) < EPS) {
            throw runtime_error("Singular matrix detected during solve.");
        }
        if (piv != k) {
            swap(A[k], A[piv]);
            swap(b[k], b[piv]);
        }
        double diag = A[k][k];
        for (int j = k; j < n; j++) A[k][j] /= diag;
        b[k] /= diag;
        for (int i = k+1; i < n; i++) {
            double factor = A[i][k];
            if (fabs(factor) < EPS) continue;
            for (int j = k; j < n; j++) {
                A[i][j] -= factor * A[k][j];
            }
            b[i] -= factor * b[k];
        }
    }
    vector<double> x(n, 0.0);
    for (int i = n-1; i >= 0; i--) {
        double sum = b[i];
        for (int j = i+1; j < n; j++) {
            sum -= A[i][j] * x[j];
        }
        x[i] = sum;
    }
    return x;
}

};

/**************************************************************************************************

•                                    MAIN
  

**************************************************************************************************/
int main(int argc, char *argv[]) {
try {
vector<Circuit> schematics;
string command_menu;

text
    while(true) {
        cout << "\n=== Main Menu ===" << endl;
        cout << "1 - Create new schematic" << endl;
        cout << "2 - Open existing schematic" << endl;
        cout << "3 - Exit" << endl;
        cout << ">>> ";
        getline(cin, command_menu);

        if(command_menu == "1") {
            // Create new schematic
            Circuit ckt;
            cout << "\nEnter circuit commands (type '.end' to finish):" << endl;

            string line;
            while(true) {
                cout << ">>> ";
                getline(cin, line);

                if(iequals(line, ".end")) {
                    try {
                        // Validate circuit before solving
                        if (!ckt.hasGroundNode()) {
                            cout << "Error: No ground node (0) detected in the circuit." << endl;
                            continue;
                        }
                        if (ckt.hasDuplicateNames()) {
                            cout << "Error: Duplicate component names detected." << endl;
                            continue;
                        }
                        if (!ckt.isConnectedCircuit()) {
                            cout << "Error: Circuit is not fully connected." << endl;
                            continue;
                        }

                        ckt.parseLine(line);  // Parse the .end command
                        ckt.solveDC();
                        schematics.push_back(move(ckt));
                        cout << "Schematic saved. Returning to main menu." << endl;
                        break;
                    } catch (const exception &ex) {
                        cerr << "Error: " << ex.what() << endl;
                        continue;
                    }
                }
                else if(iequals(line, "-show existing schematics")) {
                    showExistingSchematicsMenu();
                    continue;
                }

                try {
                    ckt.parseLine(line);
                } catch (const exception &ex) {
                    cerr << "Error: " << ex.what() << endl;
                }
            }
        }
        else if(command_menu == "2") {
            // Open existing schematic
            if(schematics.empty()) {
                cout << "No saved schematics available." << endl;
                continue;
            }

            cout << "\n=== Saved Schematics ===" << endl;
            for(size_t i = 0; i < schematics.size(); ++i) {
                cout << i+1 << " - Schematic " << i+1 << endl;
            }
            cout << "0 - Return to main menu" << endl;
            cout << ">>> ";

            string selection;
            getline(cin, selection);

            if(selection == "0") continue;

            try {
                size_t idx = stoul(selection) - 1;
                if(idx >= schematics.size()) {
                    cout << "Invalid selection." << endl;
                    continue;
                }

                // Display the selected schematic
                cout << "\n=== Schematic " << idx+1 << " ===" << endl;
                schematics[idx].printNodes();

                // List all elements
                vector<string> types = {"R", "C", "L", "D", "V", "I", "E", "F", "H", "G"};
                for(const auto& t : types) {
                    schematics[idx].printList(t);
                }

                // Option to solve again
                cout << "\nSolve this schematic again? (y/n): ";
                string solve_choice;
                getline(cin, solve_choice);

                if(toLower(solve_choice) == "y") {
                    try {
                        schematics[idx].solveDC();
                    } catch (const exception &ex) {
                        cerr << "Error solving circuit: " << ex.what() << endl;
                    }
                }
            } catch (...) {
                cout << "Invalid input. Please enter a number." << endl;
            }
        }
        else if(command_menu == "3") {
            // Exit program
            cout << "Exiting program." << endl;
            break;
        }
        else {
            cout << "Invalid option. Please try again." << endl;
        }
    }
}
catch (const exception &ex) {
    cerr << "Fatal error: " << ex.what() << endl;
    return 1;
}

return 0;

}

edit and make the tran analysis alright
and make test case for that
do not fuck the code