diff --git a/src/nub.ts b/src/nub.ts index 3b8258973cce44be0a04cc5200babf7956984832..9fcc23e3587d9b729443a188de64adbae9c27850 100644 --- a/src/nub.ts +++ b/src/nub.ts @@ -1,8 +1,8 @@ import { ParamDefinition, ParamsEquation, Session, Structure } from "."; import { ComputeNode } from "./compute-node"; import { Dichotomie } from "./dichotomie"; -import { INamedIterableValues, IterableValues } from "./param/param-value-iterator"; import { ParamValueMode } from "./param/param-value-mode"; +import { ParamValues } from "./param/param-values"; import { Props } from "./props"; import { IObservable, Observable, Observer } from "./util/observer"; import { Result } from "./util/result"; @@ -110,7 +110,8 @@ export abstract class Nub extends ComputeNode implements IObservable { public CalcSerie(rInit?: number, sDonnee?: any): Result { let computedParam: ParamDefinition; // instance de ParamValues utilisée pour le paramètre varié (qui peut être un paramètre référencé (importé)) - let variatedValues: IterableValues; + let variatedParam: ParamDefinition; + let variatedValues: ParamValues; // chain computation const requiredNubs1stLevel = Session.getInstance().getRequiredNubs(this); @@ -137,7 +138,7 @@ export abstract class Nub extends ComputeNode implements IObservable { case ParamValueMode.LISTE: case ParamValueMode.MINMAX: - variatedValues = this.setVariatedValues(p, variatedValues); + variatedParam = this.setVariatedValues(p, variatedParam); break; case ParamValueMode.CALCUL: @@ -149,17 +150,16 @@ export abstract class Nub extends ComputeNode implements IObservable { && p.referencedValue.isResult() && (p.referencedValue.element as Result).nbResultElements > 1 ) { - variatedValues = this.setVariatedValues(p, variatedValues); + variatedParam = this.setVariatedValues(p, variatedParam); } break; case ParamValueMode.LINK: if ( p.isReferenceDefined() - && p.referencedValue.isResult() - && (p.referencedValue.element as Result).nbResultElements > 1 + && p.referencedValue.hasMultipleValues() ) { - variatedValues = this.setVariatedValues(p, variatedValues); + variatedParam = this.setVariatedValues(p, variatedParam); } break; @@ -183,9 +183,13 @@ export abstract class Nub extends ComputeNode implements IObservable { rInit = computedParam.v; } - if (variatedValues === undefined) { + if (variatedParam === undefined) { this._result = this.Calc(computedSymbol, rInit); // résultat dans this._result } else { + // extract variated values from variated Parameter + // (in LINK mode, proxies to target data) + variatedValues = variatedParam.paramValues; + const res = new Result(); variatedValues.initValuesIterator(false); while (variatedValues.hasNext) { @@ -661,7 +665,7 @@ export abstract class Nub extends ComputeNode implements IObservable { /** * Sets the variated values and warns if there were already some */ - private setVariatedValues(newValues: INamedIterableValues, oldValues: IterableValues) { + private setVariatedValues(newValues: ParamDefinition, oldValues: ParamDefinition): ParamDefinition { if (oldValues === undefined) { return newValues; } else { diff --git a/src/value_ref/object_ref.ts b/src/value_ref/object_ref.ts index 99e4b08985ad3bc6088cd80160a7b3835bb53c3f..c8c1ed26341c708d0d49353a2c3b0af44879d0e2 100644 --- a/src/value_ref/object_ref.ts +++ b/src/value_ref/object_ref.ts @@ -103,13 +103,36 @@ export class LinkedValue { } if (this.isParameter()) { - // simple proxy to parameter; target might be in CALC mode - ret = (this.element as ParamDefinition).paramValues; + const targetParam = (this.element as ParamDefinition); + + // target might be in CALC mode + if (targetParam.valueMode === ParamValueMode.CALCUL) { + // if already computed, expose handmade fake param values for iterability + if (this.nub.result) { + ret = new ParamValues(); + if (targetParam.hasMultipleValues) { + const multipleRes = this.nub.result.getCalculatedValues(); + ret.setValues(multipleRes); + } else { + const singleRes = this.nub.result.vCalc; + ret.setSingleValue(singleRes); + } + } else { + // else simple parameter proxy (see below) + ret = targetParam.paramValues; + } + + } else { + // simple proxy to target parameter values; if target parameter is + // also a LINK, ParamDefinition.paramValues will recursively call + // LinkedValue.getParamValues() (this method) + ret = targetParam.paramValues; + } } else if (this.isExtraResult()) { // is result available ? if (this.nub.result) { - // handmade fake param values + // expose handmade fake param values for iterability ret = new ParamValues(); if (this.nub.resultHasMultipleValues()) {