nmr-processing 9.7.8 → 9.8.0

package/src/prediction/utils/queryByHOSE.ts

@@ -35,7 +35,7 @@ export function queryByHose(
     }
 
     for (const atomNumber of element.atoms) {
-      let atom = {
+      const atom = {
         diaIDs: [element.oclID],
         delta: res ? res[0] : null,
         atoms: [atomNumber],

package/src/ranges/markSolventSignal.ts

@@ -1,7 +1,7 @@
 import { v4 as generateID } from '@lukeed/uuid';
 
 import { NMRRangeWithIds, NMRSignal1DWithId } from '../assignment/nmrAssigment';
-import { addIDs } from '../assignment/utils/getAssignment/checkIDs';
+import { addIDs } from '../assignment/utils/generalAssignment/checkIDs';
 import { NMRPeak1D } from '../peaks/NMRPeak1D';
 import { detectSignals } from '../peaks/peaksToRanges';
 import { solventSuppression } from '../peaks/solventSuppression';
@@ -23,12 +23,12 @@ export function markSolventPeaks<T extends NMRRange>(
   const { frequency = 400 } = options;
   const ranges = addIDs(cloneArray(input)) as NMRRangeWithIds[];
 
-  let peakList: NMRPeak1DWithSignalID[] = [];
+  const peakList: NMRPeak1DWithSignalID[] = [];
   for (const range of ranges) {
     const rangeID = range.id;
     for (const signal of range.signals || []) {
       const signalID = signal.id;
-      for (let peak of signal.peaks || []) {
+      for (const peak of signal.peaks || []) {
         peakList.push({
           ...peak,
           rangeID,
@@ -43,13 +43,13 @@ export function markSolventPeaks<T extends NMRRange>(
   });
 
   const signalsWithSolvent = getSignalIDsWithSolvent(peaks);
-  for (let range of ranges) {
+  for (const range of ranges) {
     if (!range.signals) continue;
-    for (let signal of range.signals) {
+    for (const signal of range.signals) {
       if (!signalsWithSolvent.includes(signal.id)) continue;
       const signalPeaks = [];
       const solventSignalPeaks = [];
-      for (let peak of peaks) {
+      for (const peak of peaks) {
         if (peak.signalID === signal.id) {
           const { signalID, rangeID, ...newPeak } = peak;
           if (peak.kind === 'solvent') {
@@ -91,7 +91,7 @@ export function markSolventPeaks<T extends NMRRange>(
 
 function getSignalIDsWithSolvent(solventPeaks: NMRPeak1DWithSignalID[]) {
   const uniqueSignalID = new Set();
-  for (let peak of solventPeaks) {
+  for (const peak of solventPeaks) {
     if (peak.kind !== 'solvent') continue;
     uniqueSignalID.add(peak.signalID);
   }
@@ -100,7 +100,7 @@ function getSignalIDsWithSolvent(solventPeaks: NMRPeak1DWithSignalID[]) {
 
 function adaptSignals(signals: SignalIntern[]) {
   const newSignals = [];
-  for (let signal of signals) {
+  for (const signal of signals) {
     const signalResult: NMRSignal1DWithId = {
       id: generateID(),
       delta: signal.delta,

package/src/ranges/rangesToACS.ts

@@ -138,7 +138,7 @@ function pushDelta(range: NMRRange, acsRanges: string[], options: any) {
   }
 
   if (range.signals && range.signals.length > 0) {
-    let signals = range.signals;
+    const signals = range.signals;
     if (signals.length > 1) {
       if (options.ascending === true) {
         signals.sort((a, b) => {
@@ -156,7 +156,7 @@ function pushDelta(range: NMRRange, acsRanges: string[], options: any) {
             signal.multiplicity || (signal.js && signal.js.length > 0),
         )
       ) {
-        for (let signal of signals) {
+        for (const signal of signals) {
           parenthesis = [];
           if (signal.delta !== undefined) {
             strings = appendSeparator(strings);
@@ -208,7 +208,7 @@ function getIntegral(range: NMRRange, options: { nucleus: string[] }) {
 }
 
 function pushIntegral(range: NMRRange, parenthesis: string[], options: any) {
-  let integration = getIntegral(range, options);
+  const integration = getIntegral(range, options);
   if (integration.length > 0) parenthesis.push(integration);
 }
 
@@ -218,7 +218,7 @@ function pushmultiplicityFromSignal(
 ) {
   let multiplicity = signal.multiplicity;
   if (!multiplicity) {
-    let joinedCouplings = signalJoinCouplings(signal, {
+    const joinedCouplings = signalJoinCouplings(signal, {
       acsFormat: true,
       tolerance: 0.05,
       ignoreDiaIDs: true,
@@ -285,8 +285,8 @@ function pushCoupling(
       return b.coupling - a.coupling;
     });
 
-    let values = [];
-    for (let j of signal.js) {
+    const values = [];
+    for (const j of signal.js) {
       if (j.coupling !== undefined) {
         values.push(j.coupling.toFixed(options.nbDecimalJ));
       }

package/src/ranges/rangesToXY.ts

@@ -44,7 +44,7 @@ export interface RangeToXYOptions {
 function checkForSignals(
   ranges: NMRRange[],
 ): asserts ranges is RangeWithSignal[] {
-  for (let range of ranges) {
+  for (const range of ranges) {
     if (!range.signals) throw new Error('range has not signals');
   }
 }
@@ -63,7 +63,7 @@ export function rangesToXY(
   options: any = {},
 ): { x: DoubleArray; y: Float64Array } {
   checkForSignals(ranges);
-  let {
+  const {
     frequency = 400,
     lineWidth = 1,
     nbPoints = 16 * 1024,
@@ -86,7 +86,7 @@ export function rangesToXY(
     frequency,
   };
 
-  let spectrum: DoubleArray = new Float64Array(nbPoints);
+  const spectrum: DoubleArray = new Float64Array(nbPoints);
   for (const range of ranges) {
     const { integration, signals = [] } = range;
     const { multiplicity: rangeMulplicity = '' } = range;
@@ -97,10 +97,10 @@ export function rangesToXY(
         multiplicity: 'm',
       });
     }
-    let rangeSpectrum: DoubleArray = new Float64Array(nbPoints);
+    const rangeSpectrum: DoubleArray = new Float64Array(nbPoints);
     for (const signal of signals) {
       const { multiplicity } = signal;
-      let signalSpectrum =
+      const signalSpectrum =
         multiplicity === 'm' || multiplicity === 'b' || multiplicity === 'br s'
           ? broadPeakOrMultipletSpectrum([signal], spectrumOptions).y
           : hackSignalsToXY([signal], spectrumOptions).y;
@@ -127,7 +127,7 @@ function broadPeakOrMultipletSpectrum(
   const spectrumGenerator = new SpectrumGenerator(options);
 
   const broadWidth = (lineWidth * 3) / frequency;
-  for (let signal of signals) {
+  for (const signal of signals) {
     const { multiplicity, delta, integration = 1 } = signal;
     if (multiplicity === 'b' || multiplicity === 'br s') {
       spectrumGenerator.addPeak({

package/src/signal/signalJoinCouplings.ts

@@ -79,9 +79,9 @@ function groupJCouplings(
   signal.js.sort((a, b) => b.coupling - a.coupling);
 
   let currentGroup = [signal.js[0]];
-  let groups = [currentGroup];
+  const groups = [currentGroup];
   for (let i = 1; i < signal.js.length; i++) {
-    let currentJ = signal.js[i];
+    const currentJ = signal.js[i];
     if (
       comparator(currentGroup[currentGroup.length - 1], currentJ, tolerance)
     ) {
@@ -93,7 +93,7 @@ function groupJCouplings(
   }
 
   signal.js = [];
-  for (let group of groups) {
+  for (const group of groups) {
     let multiplicity = '';
     try {
       multiplicity = joinPatterns(
@@ -107,33 +107,33 @@ function groupJCouplings(
       continue;
     }
 
-    let coupling = xSum(group.map((group) => group.coupling)) / group.length;
-    let atoms = distinctValues(
+    const coupling = xSum(group.map((group) => group.coupling)) / group.length;
+    const atoms = distinctValues(
       group
         .filter((group) => group.atoms)
         .map((group) => group.atoms)
         .flat() as number[],
     ) as number[];
 
-    let assignment = distinctValues(
+    const assignment = distinctValues(
       group
         .filter((group) => group.assignment)
         .map((group) => group.assignment)
         .flat() as string[],
     ).join(' ');
 
-    let diaIDs = distinctValues(
+    const diaIDs = distinctValues(
       group
         .filter((group) => group.diaIDs)
         .map((group) => group.diaIDs)
         .flat() as string[],
     ) as string[];
 
-    let distances = distinctValues(
+    const distances = distinctValues(
       group.map((group) => group.pathLength) as number[],
     ) as number[];
 
-    let newJ: Jcoupling = {
+    const newJ: Jcoupling = {
       coupling,
       multiplicity,
     };

package/src/signal/signalMultiplicityPattern.ts

@@ -9,10 +9,10 @@ export function signalMultiplicityPattern(
   signal: NMRSignal1D,
   options?: { acsFormat?: boolean },
 ) {
-  let js = signal.js;
+  const js = signal.js;
   let pattern = '';
   if (js && js.length > 0) {
-    for (let coupling of js) {
+    for (const coupling of js) {
       const { multiplicity = '' } = coupling;
       pattern += options?.acsFormat
         ? selectACSPattern(multiplicity)

package/src/signals/addDummySignals.ts

@@ -4,7 +4,7 @@ import type { Jcoupling } from './Jcoupling';
 import { NMRSignal1D } from './NMRSignal1D';
 
 export function addDummySignals(signals: NMRSignal1D[]) {
-  let newSignals: NMRSignal1D[] = JSON.parse(JSON.stringify(signals));
+  const newSignals: NMRSignal1D[] = JSON.parse(JSON.stringify(signals));
 
   let nextAtomToAssign =
     signals.reduce((nextAtomToAssign, signal) => {
@@ -18,7 +18,7 @@ export function addDummySignals(signals: NMRSignal1D[]) {
       js: jCouplings = [],
       atoms: signalAssignment = [nextAtomToAssign++],
     } = signal;
-    let { newCouplings, tempSignals } = checkCouplings(
+    const { newCouplings, tempSignals } = checkCouplings(
       jCouplings,
       signalAssignment,
       nextAtomToAssign + signals.length,
@@ -38,13 +38,13 @@ function checkCouplings(
   signalAssignment: number[],
   nextAtomToAssign: number,
 ) {
-  let tempSignals: NMRSignal1D[] = [];
+  const tempSignals: NMRSignal1D[] = [];
   const newCouplings = jCouplings.reduce<Jcoupling[]>(
     (newCouplings, jCoupling) => {
       const { atoms = [], multiplicity, coupling } = jCoupling;
       if (atoms.length === 0) {
         if (coupling && multiplicity) {
-          let tempCouplings: Jcoupling[] = [];
+          const tempCouplings: Jcoupling[] = [];
           const nbLinks = couplingPatterns.indexOf(multiplicity);
           for (let i = 0; i < nbLinks; i++) {
             nextAtomToAssign++;

package/src/signals/hackSignalsToXY.ts

@@ -11,6 +11,6 @@ export function hackSignalsToXY(
   signals: NMRSignal1D[],
   options: OptionsSignalsToXY = {},
 ) {
-  let newSignals = addDummySignals(signals);
+  const newSignals = addDummySignals(signals);
   return signalsToXY(newSignals, options);
 }

package/src/signals/optimization/getInternalSignals.ts

@@ -60,7 +60,7 @@ export function getInternalSignals(
   options: GetInternalSignalsOptions,
 ) {
   let index = 0;
-  let internalSignals = [];
+  const internalSignals = [];
   const {
     shape: shapeAsOption = { kind: 'gaussian' },
     baseline: shiftValue = minMaxY.min,
@@ -117,7 +117,7 @@ export function getInternalSignals(
     for (const jCoupling of signal.js || []) {
       for (const property of properties) {
         const parameter = 'coupling' as Parameter;
-        let generalParameterValue =
+        const generalParameterValue =
           options?.parameters?.[parameter]?.[property];
         if (generalParameterValue) {
           if (typeof generalParameterValue === 'number') {
@@ -132,7 +132,7 @@ export function getInternalSignals(
               ),
             );
           } else {
-            let value = generalParameterValue({ jCoupling });
+            const value = generalParameterValue({ jCoupling });
             propertiesValues[property].push(
               getNormalizedValue(
                 value,
@@ -218,7 +218,7 @@ function getPropertyValue(options: {
   const { signal, frequency, parameter, property, minMaxY, shapeFct } = options;
 
   // check if the property is specified in the signal
-  let propertyValue = signal?.parameters?.[parameter]?.[property];
+  const propertyValue = signal?.parameters?.[parameter]?.[property];
   if (propertyValue) {
     return getNormalizedValue(
       propertyValue,
@@ -232,7 +232,7 @@ function getPropertyValue(options: {
 
   // check if there are some global option, it could be a number or a callback
 
-  let generalParameterValue = options?.parameters?.[parameter]?.[property];
+  const generalParameterValue = options?.parameters?.[parameter]?.[property];
   if (generalParameterValue) {
     if (typeof generalParameterValue === 'number') {
       return getNormalizedValue(
@@ -244,7 +244,7 @@ function getPropertyValue(options: {
         options.baseline,
       );
     } else {
-      let value = generalParameterValue(signal);
+      const value = generalParameterValue(signal);
       return getNormalizedValue(
         value,
         parameter,

package/src/signals/optimization/getSumOfShapes.ts

@@ -44,7 +44,7 @@ export function getSumOfShapes(
     }
     return (currentX: number) => {
       let totalY = 0;
-      for (let peak of peaks) {
+      for (const peak of peaks) {
         const { x, y, intensity, shape } = peak;
         totalY += y * intensity * shape.fct(currentX - x);
       }

package/src/signals/optimizeSignals.ts

@@ -66,7 +66,7 @@ export function optimizeSignals(
     simulation: simulationOptions,
     ...restOptions
   } = options;
-  let temp = xMinMaxValues(data.y);
+  const temp = xMinMaxValues(data.y);
   const minMaxY = { ...temp, range: temp.max - temp.min };
 
   const internalSignals = getInternalSignals(data, signals, minMaxY, {
@@ -74,7 +74,7 @@ export function optimizeSignals(
     ...restOptions,
   });
   const { baseline: shiftValue = minMaxY.min } = options;
-  let normalizedY = new Float64Array(data.y.length);
+  const normalizedY = new Float64Array(data.y.length);
   for (let i = 0; i < data.y.length; i++) {
     normalizedY[i] = (data.y[i] - shiftValue) / minMaxY.range;
   }
@@ -115,7 +115,7 @@ export function optimizeSignals(
       ? [directOptimization, defaultDirectOptimizationOptions]
       : [levenbergMarquardt, defaultLMOptimizationOptions];
 
-  let fitted = algorithm({ x: data.x, y: normalizedY }, sumOfShapes, {
+  const fitted = algorithm({ x: data.x, y: normalizedY }, sumOfShapes, {
     minValues,
     maxValues,
     initialValues,

package/src/signals/signals2DToZ.ts

@@ -39,13 +39,9 @@ export function signals2DToZ(
   signals: NMRSignal2D[],
   options: Signals2DToZOptions = {},
 ) {
-  let {
-    from = -1,
-    to = 12,
-    nbPoints = 512,
-    width = 0.02,
-    factor = 3,
-  } = options;
+  const { from = -1, to = 12, nbPoints = 512, factor = 3 } = options;
+
+  let { width = 0.02 } = options;
 
   const peaks = signals.reduce<Peak2DSeries>(
     (acc, { x, y }) => {
@@ -77,7 +73,7 @@ function ensureXYNumber(input: number | XYNumber) {
 }
 
 function mergeClosePeaks(peaksIn: Peak2DSeries) {
-  let peaks = JSON.parse(JSON.stringify(peaksIn));
+  const peaks = JSON.parse(JSON.stringify(peaksIn));
   for (let i = 0; i < peaks.x.length; i++) {
     for (let j = i + 1; j < peaks.x.length; j++) {
       if (peaks.x[i] === peaks.x[j] && peaks.y[i] === peaks.y[j]) {

package/src/signals/signalsJoin.ts

@@ -64,10 +64,10 @@ export function signalsJoin(
 
   const groupedSignals: Record<string, Signal1DWidthJsAndDiaID[]> = {};
 
-  for (let signal of copySignals) {
+  for (const signal of copySignals) {
     signal.js = signal.js.sort(localeCompareJcouplingKeys);
     const keyDiaIDs = signal.diaIDs.join(' ');
-    let id = `${keyDiaIDs} ${signal.js
+    const id = `${keyDiaIDs} ${signal.js
       .map(
         (j: JcouplingFromPrediction) => `${j.diaIDs.join(' ')} ${j.pathLength}`,
       )
@@ -82,7 +82,7 @@ export function signalsJoin(
   let newSignals: Signal1DWidthJsAndDiaID[] = [];
   Object.values(groupedSignals).forEach((group) => {
     // joining couplings only if diaID and pathLength are equal
-    let js: JcouplingFromPrediction[] = [];
+    const js: JcouplingFromPrediction[] = [];
     for (let i = 0; i < group[0].js.length; i++) {
       const coupling = group[0].js[i];
       js.push({
@@ -92,7 +92,7 @@ export function signalsJoin(
         coupling: xMean(group.map((item) => item.js[i].coupling)),
       });
     }
-    let signal: Signal1DWidthJsAndDiaID = {
+    const signal: Signal1DWidthJsAndDiaID = {
       id: generateID(),
       nbAtoms: xSum(group.map((item) => item.nbAtoms || 0)),
       delta: xMean(group.map((item) => item.delta)),
@@ -113,7 +113,7 @@ export function signalsJoin(
 
   newSignals = newSignals
     .map((signal) => {
-      let newSignal = signalJoinCouplings(signal, {
+      const newSignal = signalJoinCouplings(signal, {
         tolerance,
         ignoreDiaIDs,
       }) as Signal1DWidthJsAndDiaID;

package/src/signals/signalsToFID.ts

@@ -60,7 +60,7 @@ export function signalsToFID(
     maxClusterSize = 8,
   } = options;
 
-  let spinSystem = signalsToSpinSystem(signals);
+  const spinSystem = signalsToSpinSystem(signals);
 
   spinSystem.clusters = splitSpinSystem(spinSystem, {
     frequency,

package/src/signals/signalsToRanges.ts

@@ -31,7 +31,7 @@ interface WrappedSignal {
 function checkNbAtoms(
   signals: NMRSignal1D[],
 ): asserts signals is Signals1DWithNbAtoms[] {
-  for (let signal of signals) {
+  for (const signal of signals) {
     if (!signal.nbAtoms) throw new Error('nbAtoms is mandatory');
   }
 }
@@ -56,9 +56,9 @@ export function signalsToRanges(
 
   wrapped = wrapped.sort((signal1, signal2) => signal1.from - signal2.from);
 
-  let ranges: RangeFullfiled[] = [];
+  const ranges: RangeFullfiled[] = [];
   let range = {} as RangeFullfiled;
-  for (let signal of wrapped) {
+  for (const signal of wrapped) {
     if (range.from === undefined || signal.from > range.to) {
       range = {
         id: generateID(),

package/src/signals/signalsToXY.ts

@@ -75,7 +75,7 @@ export function signalsToXY(
   options: OptionsSignalsToXY = {},
 ) {
   checkForMandatory(signals);
-  let {
+  const {
     frequency = 400,
     shape = {
       kind: 'gaussian',
@@ -95,14 +95,14 @@ export function signalsToXY(
     };
   }
 
-  let spinSystem = signalsToSpinSystem(signals);
+  const spinSystem = signalsToSpinSystem(signals);
 
   spinSystem.clusters = splitSpinSystem(spinSystem, {
     frequency,
     maxClusterSize,
   });
 
-  let spectrum = simulate1D(spinSystem, {
+  const spectrum = simulate1D(spinSystem, {
     frequency,
     from,
     to,

package/src/signals/simulation/signalsToSpinSystem.ts

@@ -6,9 +6,7 @@ import type { NMRSignal1D } from '../NMRSignal1D';
 import type { SpinSystem } from '../spinSystem';
 import { ensureSpinSystemProps } from '../utils/ensureSpinSystemProps';
 
-interface Ids {
-  [index: number]: number;
-}
+type Ids = Record<number, number>;
 
 type JcouplingFromPrediction = MakeMandatory<Jcoupling, 'atoms'>;
 type Signal1DWidthAtomIDs = MakeMandatory<NMRSignal1D, 'atoms'>;
@@ -42,10 +40,10 @@ export function signalsToSpinSystem(signals: NMRSignal1D[]): SpinSystem {
   }
   //create the coupling matrix
   for (let i = 0; i < nSpins; i++) {
-    let { atoms: signalAssignment, js: jCoupling } = signals[i];
+    const { atoms: signalAssignment, js: jCoupling } = signals[i];
     const fromIndex = signalAssignment[0];
     for (const jcoupling of jCoupling) {
-      let { coupling, atoms } = jcoupling;
+      const { coupling, atoms } = jcoupling;
       const toIndex = atoms[0];
       couplingConstants.set(ids[fromIndex], ids[toIndex], coupling);
       couplingConstants.set(ids[toIndex], ids[fromIndex], coupling);

package/src/signals/simulation/simulate1D.ts

@@ -14,7 +14,7 @@ export function simulate1D(
   spinSystemInput: SpinSystem,
   options: Simulate1DOptions = {},
 ): DataXY {
-  let {
+  const {
     lineWidth = 1,
     frequency: frequencyMHz = 400,
     from = 0,
@@ -26,7 +26,7 @@ export function simulate1D(
   } = options;
 
   const spinSystem = ensureSpinSystemProps(spinSystemInput);
-  let peakWidth = lineWidth / frequencyMHz;
+  const peakWidth = lineWidth / frequencyMHz;
 
   const xyPeaks = simulateXYPeaks(spinSystem, options);
 

package/src/signals/simulation/simulateXYPeaks.ts

@@ -56,7 +56,7 @@ export function simulateXYPeaks(
   spinSystemInput: SpinSystem,
   options: Simulate1DOptions = {},
 ) {
-  let {
+  const {
     lineWidth = 1,
     maxClusterSize = 8,
     frequency: frequencyMHz = 400,
@@ -73,13 +73,13 @@ export function simulateXYPeaks(
 
   const xyPeaks: Array<{ x: number; y: number }> = [];
   for (const cluster of spinSystem.clusters) {
-    let clusterFake = cluster.map((cluster) =>
+    const clusterFake = cluster.map((cluster) =>
       cluster < 0 ? -cluster - 1 : cluster,
     );
     let weight = 1;
     let sumI = 0;
-    let frequencies: number[] = [];
-    let intensities: number[] = [];
+    const frequencies: number[] = [];
+    const intensities: number[] = [];
     if (cluster.length > maxClusterSize) {
       // This is a single spin, but the cluster exceeds the maxClusterSize criteria
       // we use the simple multiplicity algorithm
@@ -90,8 +90,9 @@ export function simulateXYPeaks(
       frequencies.push(-chemicalShifts[index]);
       for (let i = 0; i < cluster.length; i++) {
         if (cluster[i] < 0) {
-          let jc = spinSystem.couplingConstants.get(index, clusterFake[i]) / 2;
-          let currentSize = frequencies.length;
+          const jc =
+            spinSystem.couplingConstants.get(index, clusterFake[i]) / 2;
+          const currentSize = frequencies.length;
           for (let j = 0; j < currentSize; j++) {
             frequencies.push(frequencies[j] + jc);
             frequencies[j] -= jc;
@@ -149,7 +150,7 @@ export function simulateXYPeaks(
       assignmentMatrix.forEachNonZero((i, j, v) => {
         if (v > 0) {
           for (let k = 0; k < V.columns; k++) {
-            let element = V.get(j, k);
+            const element = V.get(j, k);
             if (element !== 0) {
               rhoip.set(i, k, rhoip.get(i, k) + element);
             }
@@ -162,7 +163,7 @@ export function simulateXYPeaks(
       assignmentMatrix.forEachNonZero((i: number, j: number, v: number) => {
         if (v < 0) {
           for (let k = 0; k < V.columns; k++) {
-            let element = V.get(j, k);
+            const element = V.get(j, k);
             if (element !== 0) {
               rhoip2.set(i, k, rhoip2.get(i, k) + element);
             }
@@ -192,8 +193,8 @@ export function simulateXYPeaks(
         val *= val;
 
         sumI += val;
-        let valFreq = diagB[i] - diagB[j];
-        let insertIn = binarySearch(
+        const valFreq = diagB[i] - diagB[j];
+        const insertIn = binarySearch(
           frequencies,
           valFreq,
           (a: number, b: number) => a - b,
@@ -270,22 +271,21 @@ function getHamiltonian(
   const clusterHam = new SparseMatrix(hamSize, hamSize);
 
   for (let pos = 0; pos < cluster.length; pos++) {
-    let n = cluster[pos];
+    const n = cluster[pos];
 
     const L = getPauliMatrix(multiplicity[n]);
 
-    let A1, B1;
     let temp = 1;
     for (let i = 0; i < pos; i++) {
       temp *= multiplicity[cluster[i]];
     }
-    A1 = SparseMatrix.eye(temp);
+    const A1 = SparseMatrix.eye(temp);
 
     temp = 1;
     for (let i = pos + 1; i < cluster.length; i++) {
       temp *= multiplicity[cluster[i]];
     }
-    B1 = SparseMatrix.eye(temp);
+    const B1 = SparseMatrix.eye(temp);
 
     const alpha = chemicalShifts[n];
     const kronProd = A1.kroneckerProduct(L.z).kroneckerProduct(B1);
@@ -295,18 +295,17 @@ function getHamiltonian(
       if (conMatrix.get(n, k) === 1) {
         const S = getPauliMatrix(multiplicity[k]);
 
-        let A2, B2;
         let temp = 1;
         for (let i = 0; i < pos2; i++) {
           temp *= multiplicity[cluster[i]];
         }
-        A2 = SparseMatrix.eye(temp);
+        const A2 = SparseMatrix.eye(temp);
 
         temp = 1;
         for (let i = pos2 + 1; i < cluster.length; i++) {
           temp *= multiplicity[cluster[i]];
         }
-        B2 = SparseMatrix.eye(temp);
+        const B2 = SparseMatrix.eye(temp);
 
         const kron1 = A1.kroneckerProduct(L.x)
           .kroneckerProduct(B1)