/**
 * 
 * Dieser Code dient dazu, die Testkennwerte von Screening- Verfahren zu
 * berechnen. Hierzu werden die Angaben zu Korrekt positiven, korrekt negativen,
 * falsch positiven und falsch negativen Ergebnissen benoetigt. Die Klasse er-
 * mittelt Sensitivitaet, Spezifitaet, den positiven und negativen praediktiven
 * Wert, Treffer- und Zufallstreffer- rate, sowie den RATZ-Index. Das Programm
 * steht unter unter der Lizenz GNU GPL (http://www.gnu.org/licenses/gpl.html),
 * d. h. sie dürfen den Code frei verwenden, sofern Sie diese Meldung intakt
 * lassen. Weiterhin müssen Sie den Source-Code von Software, die diesen Code
 * beinhaltet ebenfalls unter den Bedingungen der GPL frei verfügbar machen.
 * Bitte beachten Sie hierzu die Bedingungen der Free Software Foundation.
 * 
 * This code serves for calculating test values for screenings (specifity,
 * sensitivity, positive predictive value, negative predictive value, random hit
 * ratio, hit ratio and the relative increase of hit ratio compared to the
 * random hit ratio (RATZ-Index).
 * 
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * @author Dr. Wolfgang Lenhard, 2010
 * 
 *         Zitierfähige Quelle: Lenhard, W. (2010). Auswertungshilfe zur
 *         Berechnung von Testkennwerten von Screeningverfahren. verfuegbar
 *         unter http://www.psychometrica.de/testkennwerte.html. Dettelbach:
 *         Psychometrica.
 * 
 * 
 */
public class TestStatistics {

	/**
	 * Sensitivitaet: Anteil korrekt erkannter Risikopersonen
	 */
	private float sensitivity = -1.0f;

	/**
	 * Spezifitaet: Anteil korrekt erkannter Nicht-Risiko-Personen
	 */
	private float specifity = -1.0f;

	/**
	 * Positiver praediktiver Wert: Wahrscheinlichkeit, im Falle eines positiven
	 * Ergebnisses tatsächlich betroffen zu sein
	 */
	private float positivePredictiveValue = -1.0f;

	/**
	 * Negativer praediktiver Wert: Wahrscheinlichkeit, im Falle eines negativen
	 * Ergebnisses tatsächlich nicht betroffen zu sein
	 */
	private float negativePredictiveValue = -1.0f;

	/**
	 * tatsächliche Trefferquote
	 */
	private float hitRatio = -1.0f;

	/**
	 * maximal moegliche Trefferquote
	 */
	private float maximalHitRatio = -1.0f;

	/**
	 * Zufallstrefferquote: Anteil an Treffern, die auf der Basis zufaelliger
	 * Zuweisung zu den verschiedenen Kategorien zu erwarten ist
	 */
	private float randomHitRatio = -1.0f;

	/**
	 * RATZ-Index: Relativer Anstieg der Trefferquote gegenueber der
	 * Zufallstrefferquote
	 */
	private float ratzIndex = -1.0f;

	/**
	 * Korrekt positive Ergebnisse
	 */
	private float correctPositive = .0f;

	/**
	 * Korrekt negative Ergebnisse
	 */
	private float correctNegative = .0f;

	/**
	 * Falsch positive Ergebnisse
	 */
	private float falsePositive = .0f;

	/**
	 * Falsch negative Ergebnisse
	 */
	private float falseNegative = .0f;

	/**
	 * Stichprobengroesse
	 */
	private float total = .0f;

	/**
	 * @param correctPositive
	 *            Korrekt positive Ergebnisse eines Testverfahrens
	 * @param correctNegative
	 *            Korrekt positive Ergebnisse eines Testverfahrens
	 * @param falsePositive
	 *            Falsch positive Ergebnisse eines Testverfahrens
	 * @param falseNegative
	 *            Falsch negative Ergebnisse eines Testverfahrens
	 */
	public TestStatistics(int correctPositive, int correctNegative,
			int falsePositive, int falseNegative) {
		this.correctPositive = correctPositive;
		this.correctNegative = correctNegative;
		this.falsePositive = falsePositive;
		this.falseNegative = falseNegative;
		this.total = this.correctNegative + this.correctPositive
				+ this.falseNegative + this.falsePositive;
		this.sensitivity = this.correctPositive
				/ (this.correctPositive + this.falseNegative);
		this.specifity = this.correctNegative
				/ (this.correctNegative + this.falsePositive);
		this.positivePredictiveValue = this.correctPositive
				/ (this.correctPositive + this.falsePositive);
		this.negativePredictiveValue = this.correctNegative
				/ (this.correctNegative + this.falseNegative);
		this.hitRatio = (this.correctNegative + this.correctPositive) / total;
		this.maximalHitRatio = 1.0f - (Math.abs(this.falsePositive
				- this.falseNegative) / total);
		this.randomHitRatio = ((this.correctPositive + this.falseNegative)
				* (this.correctPositive + this.falsePositive) / (total * total));
		this.randomHitRatio += ((this.correctNegative + this.falseNegative)
				* (this.correctNegative + this.falsePositive) / (total * total));
		this.ratzIndex = (this.hitRatio - this.randomHitRatio)
				/ (this.maximalHitRatio - this.randomHitRatio);
	}

	/**
	 * @return Sensitivitaet
	 */
	public float getSensitivity() {
		return sensitivity;
	}

	/**
	 * @return Speyifitaet
	 */
	public float getSpecifity() {
		return specifity;
	}

	/**
	 * @return Positiver praediktiver Wert
	 */
	public float getPositivePredictiveValue() {
		return positivePredictiveValue;
	}

	/**
	 * @return negativer praediktiver Wert
	 */
	public float getNegativePredictiveValue() {
		return negativePredictiveValue;
	}

	/**
	 * @return Trefferquote
	 */
	public float getHitRatio() {
		return hitRatio;
	}

	/**
	 * @return maximal moegliche Trefferquote
	 */
	public float getMaximalHitRatio() {
		return maximalHitRatio;
	}

	/**
	 * @return Zufallstrefferquote
	 */
	public float getRandomHitRatio() {
		return randomHitRatio;
	}

	/**
	 * @return Relativer Anstieg der Trefferquote gegenueber der
	 *         Zufallstrefferquote
	 */
	public float getRatzIndex() {
		return ratzIndex;
	}

	/**
	 * @return Anzahl korrekt positiver Ergebnisse
	 */
	public int getCorrectPositive() {
		return (int) correctPositive;
	}

	/**
	 * @return Anzahl korrekt negativer Ergebnisse
	 */
	public int getCorrectNegative() {
		return (int) correctNegative;
	}

	/**
	 * @return Anzahl falsch positiver Ergebnisse
	 */
	public int getFalsePositive() {
		return (int) falsePositive;
	}

	/**
	 * @return Anzahl falsch negativer Ergebnisse
	 */
	public int getFalseNegative() {
		return (int) falseNegative;
	}
}