get an 6 input from users 3 voltage phasors and 3 current phasors and plot the phasors and find its sequence components in javascript

index.tsx
// Prompt the user for 6 inputs
const voltagePhasors = [];
const currentPhasors = [];
for (let i = 1; i <= 3; i++) {
  const voltage = prompt(`Enter voltage phasor ${i} (in polar form):`);
  const current = prompt(`Enter current phasor ${i} (in polar form):`);

  voltagePhasors.push(parsePhasor(voltage));
  currentPhasors.push(parsePhasor(current));
}

// Parse the polar form of the phasor into its components
function parsePhasor(input) {
  const parts = input.trim().split(/[\s,]+/);
  const magnitude = parseFloat(parts[0]);
  const angle = parseFloat(parts[1]);

  return {
    magnitude,
    angle
  };
}
613 chars
23 lines

index.tsx
// Create a scatter plot
const ctx = document.getElementById('myChart').getContext('2d');
const chart = new Chart(ctx, {
  type: 'scatter',
  data: {
    datasets: [{
      label: 'Voltage Phasors',
      data: voltagePhasors.map(phasor => ({
        x: phasor.magnitude * Math.cos(phasor.angle),
        y: phasor.magnitude * Math.sin(phasor.angle)
      })),
      pointBackgroundColor: 'blue',
    }, {
      label: 'Current Phasors',
      data: currentPhasors.map(phasor => ({
        x: phasor.magnitude * Math.cos(phasor.angle),
        y: phasor.magnitude * Math.sin(phasor.angle)
      })),
      pointBackgroundColor: 'red',
    }]
  },
  options: {
    scales: {
      x: {
        type: 'linear',
        position: 'bottom'
      },
      y: {
        type: 'linear',
        position: 'left'
      }
    }
  }
});
827 chars
35 lines

index.tsx
// Calculate sequence components
const a = complex(Math.cos((2 * Math.PI) / 3), Math.sin((2 * Math.PI) / 3));

const positiveSequence = [];
const negativeSequence = [];
const zeroSequence = [];

for (let i = 0; i < 3; i++) {
  const va = voltagePhasors[i];
  const ia = currentPhasors[i];

  const vp = complex(va.magnitude, va.angle);
  const ip = complex(ia.magnitude, ia.angle);

  const vn = complex.mul(a, vp);
  const in = complex.mul(a, ip);

  const vz = complex.mul(a, vn);
  const iz = complex.mul(a, in);

  positiveSequence.push({
    voltage: polarForm(vp),
    current: polarForm(ip)
  });
  negativeSequence.push({
    voltage: polarForm(vn),
    current: polarForm(in)
  });
  zeroSequence.push({
    voltage: polarForm(vz),
    current: polarForm(iz)
  });
}

// Complex number class
function complex(real, imaginary) {
  return {
    real,
    imaginary,
    add: function (other) {
      return complex(this.real + other.real, this.imaginary + other.imaginary);
    },
    mul: function (other) {
      return complex(
        this.real * other.real - this.imaginary * other.imaginary,
        this.real * other.imaginary + this.imaginary * other.real
      );
    }
  };
}

// Convert a complex number to polar form
function polarForm(complexNumber) {
  const magnitude = Math.sqrt(
    complexNumber.real ** 2 + complexNumber.imaginary ** 2
  );
  const angle = Math.atan2(complexNumber.imaginary, complexNumber.real);

  return {
    magnitude,
    angle
  };
}
1484 chars
64 lines