com.anrisoftware.gsanalysis.synthesis.SynthesisFromPosition Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gsanalysis-synthesis Show documentation
Calculates the value from a Global Scaling continued fraction.
The newest version!
/*
 * Copyright 2015 Erwin Müller 
 *
 * This file is part of gsanalysis-synthesis. All rights reserved.
 */
package com.anrisoftware.gsanalysis.synthesis;

import java.util.concurrent.Callable;

import javax.inject.Inject;

import com.anrisoftware.globalpom.measurement.Measure;
import com.anrisoftware.gsanalysis.core.Analysis;
import com.anrisoftware.gsanalysis.core.AnalysisFactory;
import com.anrisoftware.gsanalysis.core.Denominator;
import com.anrisoftware.gsanalysis.core.Fraction;
import com.anrisoftware.gsanalysis.core.FractionFactory;
import com.anrisoftware.gsanalysis.core.Gauge;
import com.anrisoftware.gsanalysis.core.Phase;
import com.anrisoftware.gsanalysis.core.Synthesis;
import com.google.inject.assistedinject.Assisted;

/**
 * Calculates the measure from the position inside the fractal.
 *
 * @author Erwin Müller, [email protected]
 * @since 3.2
 */
@SuppressWarnings("rawtypes")
public class SynthesisFromPosition implements Callable {

    private final FractionFactory fractionFactory;

    private final AnalysisFactory analysisFactory;

    private final Fraction fraction;

    private final Gauge gauge;

    private final Phase phase;

    private final double position;

    private final Measure measure;

    private final SynthesisFactory synthesisFactory;

    private Fraction resultFraction;

    private Measure resultMeasure;

    /**
     * @see SynthesisFromPositionFactory#create(FractionFactory,
     *      AnalysisFactory, SynthesisFactory, Fraction, Gauge, Measure, Phase,
     *      double)
     */
    @Inject
    SynthesisFromPosition(@Assisted FractionFactory fractionFactory,
            @Assisted AnalysisFactory analysisFactory,
            @Assisted SynthesisFactory synthesisFactory,
            @Assisted Fraction fraction, @Assisted Gauge gauge,
            @Assisted Measure measure, @Assisted Phase phase,
            @Assisted double position) {
        this.fractionFactory = fractionFactory;
        this.analysisFactory = analysisFactory;
        this.synthesisFactory = synthesisFactory;
        this.fraction = fraction;
        this.gauge = gauge;
        this.measure = measure;
        this.phase = phase;
        this.position = position;
    }

    @Override
    public SynthesisFromPosition call() {
        Fraction trimmedFraction = fraction.trim(1, fractionFactory);
        Denominator d0 = trimmedFraction.get(0);
        double log = position * 2.0 + d0.getValue() - 1;
        Analysis analysis = analysisFactory.create(gauge, measure, d0, log,
                phase).call();
        Synthesis synthesis = synthesisFactory.create(analysis.getFraction(),
                gauge, phase).call();
        this.resultFraction = synthesis.getFraction();
        this.resultMeasure = synthesis.getMeasure();
        return this;
    }

    public Fraction getResultFraction() {
        return resultFraction;
    }

    public Measure getResultMeasure() {
        return resultMeasure;
    }
}