//
//Name: Utcdak.java
//Version: 1.0
//Date: 06/22/97
//Author: Ferdi Hellweger
//        Center for Resarch in Water Resources
//        The University of Texas at Austin
//        Austin, TX 78712
//        (512) 471-6855
//        ferdi@crwr.utexas.edu
//        www.ce.utexas.edu/stu/ferdi/
//Description: This applet is a statistical calculator.  It calculates
//             the mean and standard deviation for a sample that contains
//             censored data using several different methods.
//
//
//methods:
//
//r = real
//z = zero
//h = half detection limit
//d = detection limit
//x = delete
//m = median
//t = trimmed
//w = winsorized
//c = cohen
//
//-------------------------
//--- import some stuff ---
//-------------------------
//
import java.awt.*;
import java.applet.*;
import java.io.*;
//
//---------------------
//--- define applet ---
//---------------------
//
public class Utcdak extends Applet {
	//
	//--- declare variables ---
	//
	//labels:
	//
	//lver = version
	//ld = data
	//ldv = data value
	//ldls = dl single
	//ldlm = dl multiple
	//lm = method
	//ldum1..5 = dummy
	//
	Label lver, ld[], ldv, ldls, ldlm, lm, ldum1, ldum2, ldum3, ldum4, ldum5;
	//
	//texfields:
	//
	//fdv = data value
	//fdls = dl single
	//fdlm = dl multiple
	//
	TextField fdv[], fdls, fdlm[];
	//
	//buttons:
	//
	//bc = calculate
	//bup = scroll up
	//bdn = scroll down
	//
	Button bc, bup, bdn;
	//
	//panels:
	//
	//pn = north
	//pw = west
	//ps = south
	//pe = east
	//pwn = west-north
	//pwc = west-center
	//pws = west-south
	//
	Panel pn, pw, ps, pe, pwn, pwc, pws;
	//
	//string:
	//
	//sdv = data value
	//sdlm = dl multiple
	//sdls = dl single
	//desc = description
	//
	String sdv[], sdlm[], sdls;
	String desc;
	//
	//float:
	//
	//ddv = dta value
	//ddlm = dl multiple
	//ddls = dl single
	//ddl = dl
	//realres, etc. = method results
	//datamax = drawing stuff
	//
	double ddv[], ddlm[], ddls, ddl[];
	double realres[], zerores[], halfres[], dlres[], medres[], delres[], trimres[], winres[], cohenres[];
	double datamax;
	//
	//integer:
	//
	//idf = index for data scroll
	//datadim = data dimension
	//maxdim = max dim for program
	//offx, etc. = drawing stuff
	//
	int idf, datadim, maxdim;
	int offx, offy, axisx, axisy, count, mybreak, breaks, mi, offt;
	//
	//color:
	//
	Color mycolor;
	//
	//checkboxes:
	//
	//cr, etc. = methods
	//cdls = single dl
	//cdlm = multiple dl
	//
	Checkbox cr, cz, ch, cd, cx, cm, ct, cw, cc;
	Checkbox cdls, cdlm;
	//
	//radiobuttons:
	//
	//cbg = single or multiple dl
	//
	CheckboxGroup cbg;
	//
	//--- set up application window ---
	//
	//this is only executed for application
	//
	public static void main(String args[]) throws IOException {
		//variables
		Utcdak myutcdak;
		Frame f;
		DataInputStream is;
		StreamTokenizer il;
		String myline;
        int indim;
		boolean singledl;
		String firstdl;
		//calculation
		f = new Frame("UTCDAK - Censored Data Analysis Kit");
		myutcdak = new Utcdak();
		myutcdak.init();
		myutcdak.start();
		firstdl = "ND";
		if (args.length > 0) {
			is = new DataInputStream(new FileInputStream(args[0]));
			il = new StreamTokenizer(new StringBufferInputStream(is.readLine()));
			il.eolIsSignificant(true);
			il.nextToken();
			indim = (int) il.nval;
			singledl = false;
		    for (int i = 0; i < indim; i++) {
				il = new StreamTokenizer(new StringBufferInputStream(is.readLine()));
				il.nextToken();
				if (il.ttype == StreamTokenizer.TT_WORD) {
					myutcdak.sdv[i] = il.sval;
				}
				if (il.ttype == StreamTokenizer.TT_NUMBER) {
					myutcdak.sdv[i] = String.valueOf(il.nval);
				}
				il.nextToken();
				if (i == 0) {
					if (il.ttype == StreamTokenizer.TT_WORD) {
						firstdl = il.sval;
					}
					if (il.ttype == StreamTokenizer.TT_NUMBER) {
						firstdl = String.valueOf(il.nval);
					}
				}
				if (il.ttype == StreamTokenizer.TT_EOF) {
					singledl = true;
				}
				if (singledl) {
					myutcdak.sdlm[i] = firstdl;
				}
				if (! singledl) {
					if (il.ttype == StreamTokenizer.TT_WORD) {
					    myutcdak.sdlm[i] = il.sval;	
					}
					if (il.ttype == StreamTokenizer.TT_NUMBER) {
						myutcdak.sdlm[i] = String.valueOf(il.nval);
					}
				}
			}
		    for (int i = indim; i < myutcdak.maxdim; i++) {
				myutcdak.sdv[i] = "";
				myutcdak.sdlm[i] = "";
			}
			if (singledl) {
				myutcdak.cdls.setState(true);
				myutcdak.sdls = String.valueOf(firstdl);
			}
			if (! singledl) {
				myutcdak.cdlm.setState(true);
			}
			myutcdak.examval();
			myutcdak.setval();
			myutcdak.calculate();
		}
		f.add("Center", myutcdak);
		f.resize(700, 500);
		f.show();
	}
	//
	//--- initiate the applet ---
	//
	public void init() {
		//
		//dimension arrays
		//
		ld = new Label[10];
		fdv = new TextField[10];
		fdlm = new TextField[10];
		//
		maxdim = 1000;
		//
		sdv = new String[maxdim];
		ddv = new double[maxdim];
		sdlm = new String[maxdim];
		ddlm = new double[maxdim];
		ddl = new double[maxdim];
		//
		realres = new double[3];
		zerores = new double[3];
		halfres = new double[3];
		dlres = new double[3];
		medres = new double[3];
		delres = new double[3];
		trimres = new double[3];
		winres = new double[3];
		cohenres = new double[3];
		//
		//assign default data
		//
		sdv[0] = "6.9";
		sdv[1] = "7.8";
		sdv[2] = "8.9";
		sdv[3] = "5.2";
		sdv[4] = "7.7";
		sdv[5] = "9.6";
		sdv[6] = "8.7";
		sdv[7] = "6.7";
		sdv[8] = "4.8";
		sdv[9] = "8.0";
		sdv[10] = "10.1";
		sdv[11] = "8.5";
		sdv[12] = "6.5";
		sdv[13] = "9.2";
		sdv[14] = "7.4";
		sdv[15] = "6.3";
		sdv[16] = "5.6";
		sdv[17] = "7.3";
		sdv[18] = "8.3";
		sdv[19] = "7.2";
		sdv[20] = "7.5";
		sdv[21] = "6.1";
		sdv[22] = "9.4";
		sdv[23] = "5.4";
		sdv[24] = "7.6";
		sdv[25] = "8.1";
		sdv[26] = "7.9";
		//
		for (int i = 27; i < maxdim; i++) {
			sdv[i] = "";
		}
		//
		for (int i = 0; i < 27; i++) {
			sdlm[i] = "6.0";
		}
		for (int i = 27; i < maxdim; i++) {
			sdlm[i] = "";
		}
		//
		realres[2] = 2;
		zerores[2] = 2;
		halfres[2] = 2;
		dlres[2] = 2;
		medres[2] = 2;
		delres[2] = 2;
		trimres[2] = 2;
		winres[2] = 2;
		cohenres[2] = 2;
		//
		sdls = "6.0";
		//
		//define layout
		//
		setBackground(Color.lightGray);
		setLayout(new BorderLayout());
		//
		pn = new Panel();
		add("North", pn);
		pn.setLayout(new GridLayout(1, 1));
		//
		pw = new Panel();
		add("West", pw);
		pw.setLayout(new BorderLayout());
		//
		pe = new Panel();
		add("East", pe);
		pe.setLayout(new GridLayout(10, 1));
		//
		ps = new Panel();
		add("South", ps);
		ps.setLayout(new GridLayout(2, 4));
		//
		pwn = new Panel();
		pw.add("North", pwn);
		pwn.setLayout(new GridLayout(1,3));
		//
		pwc = new Panel();
		pw.add("Center", pwc);
		pwc.setLayout(new GridLayout(10,3));
		//
		pws = new Panel();
		pw.add("South", pws);
		pws.setLayout(new GridLayout(1,3));
		//
		//define labels and fields
		//
		ldum1 = new Label("");
		ldum2 = new Label("");
		ldum3 = new Label("");
		ldum4 = new Label("");
		ldum5 = new Label("");
		//
		lver = new Label("UTCDAK Version 1.0", Label.LEFT);
		//
		ldv = new Label("VALUE:", Label.LEFT);
		ldlm = new Label("DL:", Label.LEFT);
		//
		ldls = new Label("Single DL:", Label.RIGHT);
		fdls = new TextField(sdls);
		//
		for (int i = 0; i < 10; i++) {
			ld[i] = new Label("", Label.RIGHT);
			fdv[i] = new TextField("");
			fdlm[i] = new TextField("");
		}
		idf = 0;
		//
		lm = new Label("METHOD:", Label.LEFT);
		//
		//define buttons
		//
		bc = new Button("Calculate");
		bup = new Button("UP");
		bdn = new Button("DOWN");
		//
		//define check boxes
		//
		cr = new Checkbox("Real", null, true);
		cz = new Checkbox("Zero", null, true);
		ch = new Checkbox("Half DL", null, false);
		cd = new Checkbox("DL", null, true);
		cx = new Checkbox("Delete", null, false);
		cm = new Checkbox("Median", null, false);
		ct = new Checkbox("Trimmed", null, false);
		cw = new Checkbox("Winsorized", null, false);
		cc = new Checkbox("Cohen", null, false);
		//
		cbg = new CheckboxGroup();
		cdlm = new Checkbox("Multiple DL", cbg, true);
		cdls = new Checkbox("Single DL", cbg, false);
		//
		//add stuff to layout
		//
		pwn.add("", bup);
		pwn.add("", ldv);
		pwn.add("", ldlm);
		pws.add("", bdn);
		pws.add("", ldum1);
		pws.add("", ldum2);
		for (int i = 0; i < 10; i++) {
			pwc.add("", ld[i]);
			pwc.add("", fdv[i]);
			pwc.add("", fdlm[i]);
		}
		//
		pn.add("", lver);
		//
		pe.add("", lm);
		pe.add("", cr);
		pe.add("", cz);
		pe.add("", ch);
		pe.add("", cd);
		pe.add("", cx);
		pe.add("", cm);
		pe.add("", ct);
		pe.add("", cw);
		pe.add("", cc);
		//
		ps.add("", cdlm);
		ps.add("", ldum3);
		ps.add("", ldum4);
		ps.add("", ldum5);
		ps.add("", cdls);
		ps.add("", ldls);
		ps.add("", fdls);
		ps.add("", bc);
		//
		examval();
		setval();
		calculate();
		repaint();
	}
	//
	//--- action ---
	//
	public boolean action(Event evt, Object arg) {
		//
		//get textfield values
		//
		getval();
		//
		//examine values
		//
		examval();
		//
		//scroll down
		//
		if (arg.equals("DOWN")) {
			if (idf < (maxdim - 10)) {
				idf = idf + 1;
				setval();
			}
			repaint();
		}
		//
		//scroll up
		//
		if (arg.equals("UP")) {
			if (idf > 0) {
				idf = idf - 1;
				setval();
			}
			repaint();
		}
		//
		//calculate
		//
		if (arg.equals("Calculate")) {
			calculate();
			repaint();
		}
		//
		//set textfield values
		//
		setval();
		//
		//return
		//
		return true;
		}
	//
	//--- get textfield values ---
	//
	public void getval() {
		//
		//get strings from textfields
		//
		//get single dl
		sdls = fdls.getText();
		//get others
		for (int i = 0; i < 10; i++) {
			sdv[idf + i] = fdv[i].getText();
			sdlm[idf + i] = fdlm[i].getText();
		}
	}
	//
	//--- examine values ---
	//
	public void examval() {
		//variables
		double ddvt1[], ddvt2[], ddlt1[], ddlt2[];
		boolean insert;
		//
		//data dimension querry
		//
		datadim = 0;
		for (int i = 0; i < maxdim; i++) {
			if (! (sdv[i].equals(""))) {
				datadim = datadim + 1;
			}
		}
		//
		//convert string to float
		//
		//single dl
		if (sdls.equals("")) {
			ddls = -1;
		}
		if (! (sdls.equals(""))) {
		    ddls = Double.valueOf(sdls).doubleValue();
		}
		//arrays
		for (int i = 0; i < datadim; i++) {
			if (sdv[i].equals("")) {
				ddv[i] = -1;
			}
			if (sdv[i].equals("BDL")) {
				ddv[i] = -2;
			}
			if (! ((sdv[i].equals("")) || (sdv[i].equals("BDL")))) {
			    ddv[i] = Double.valueOf(sdv[i]).doubleValue();
			}
			if (sdlm[i].equals("")) {
				ddlm[i] = -1;
			}
			if (sdlm[i].equals("ND")) {
				ddlm[i] = -2;
			}
			if (! ((sdlm[i].equals("")) || (sdlm[i].equals("ND")))) {
				ddlm[i] = Double.valueOf(sdlm[i]).doubleValue();
			}
		}
		//
		//polulate  detection limit array
		//
		for (int i = 0; i < datadim; i++) {
			if (cdlm.getState()) {
				ddl[i] = ddlm[i];
			}
			if (cdls.getState()) {
				ddl[i] = ddls;
			}
		}
		//
		//data sorting
		//
		//dimension temporary arrays
		ddvt1 = new double[maxdim];
		ddvt2 = new double[maxdim];
		ddlt1 = new double[maxdim];
		ddlt2 = new double[maxdim];
		//sort data
		int n = 0;
		for (int i = 0; i < datadim; i++) {
		n = n + 1;
			insert = false;
			for (int j = 0; j < n; j++) {
				if (insert) {
					ddvt2[j] = ddvt1[j - 1];
					ddlt2[j] = ddlt1[j - 1];
				}
				if (! insert) {
					//end reached
					if (j == (n - 1)) {
						ddvt2[j] = ddv[i];
						ddlt2[j] = ddl[i];
					}
					//end not reached
					if (j < (n - 1)) {
						//value is lower
						if (ddv[i] < ddvt1[j]) {
							ddvt2[j] = ddv[i];
							ddlt2[j] = ddl[i];
							insert = true;
						}
						//value is not lower
						if (! (ddv[i] < ddvt1[j])) {
							ddvt2[j] = ddvt1[j];
							ddlt2[j] = ddlt1[j];
						}
					}
				}
			}
			for (int j = 0; j < n; j++) {
				ddvt1[j] = ddvt2[j];
				ddlt1[j] = ddlt2[j];
			}
		}
		for (int i = 1; i < datadim; i++) {
			if (ddvt2[i] < ddvt2[i - 1]) {
				fdls.setText("Error Sorting Data");
			}
		}
		//
		ddv = ddvt2;
		ddl = ddlt2;
	}
	//
	//--- set textfield values ---
	//
	public void setval() {
		//
 		//disable/enable fields
		//
		if (cdls.getState()) {
			fdls.enable();
		}
		if (cdlm.getState()) {
			fdls.disable();
		}
		for (int i = 0; i < 10; i++) {
			//
			//set data label
			//(data label is index + 1)
			//
			ld[i].setText(String.valueOf(idf + i + 1) + ":");
			//
			//color BDL red
			//
			fdv[i].setForeground(Color.black);
			fdlm[i].setForeground(Color.black);
			//BDL supplied
			if (sdv[idf + i].equals("BDL")) {
				fdv[i].setForeground(Color.red);
				if (cdlm.getState()) {
					fdlm[i].setForeground(Color.red);
				}
			}
			//DV < DL
			if (! ((sdv[idf + i].equals("BDL")) || (sdv[idf + i].equals("")))) {
				if (cdls.getState()) {
					if (Double.valueOf(sdv[idf + i]).doubleValue() < Double.valueOf(sdls).doubleValue()) {
						fdv[i].setForeground(Color.red);
					}
				}
				if (cdlm.getState()) {
					if (! ((sdlm[idf + i].equals("ND")) || (sdlm[idf + i].equals("")))) {
						if (Double.valueOf(sdv[idf + i]).doubleValue() < Double.valueOf(sdlm[idf + i]).doubleValue()) {
							fdv[i].setForeground(Color.red);
							fdlm[i].setForeground(Color.red);
						}
					}
				}
			}
			//
 			//disable/enable fields
			//
			if (cdls.getState()) {
				fdlm[i].disable();
			}
			if (cdlm.getState()) {
	 			fdlm[i].enable();
				}
			//
			//set data value
			//
			fdv[i].setText(sdv[idf + i]);
			fdlm[i].setText(sdlm[idf + i]);
		}
	}
	//
	//--- calculate ---
	//
	public boolean calculate() {
		//
		//make input string
		//
		double[][] myinputs = {ddv, ddl};
		//
		//compute real
		//
		if (cr.getState()) {
			realres = realcomp(myinputs);
		}
		//
		//compute zero
		//
		if (cz.getState()) {
			zerores = zerocomp(myinputs);
		}
		//
		//compute half
		//
		if (ch.getState()) {
			halfres = halfcomp(myinputs);
		}
		//
		//compute dl
		//
		if (cd.getState()) {
			dlres = dlcomp(myinputs);
		}
		//
		//compute delete
		//
		if (cx.getState()) {
			delres = delcomp(myinputs);
		}
		//
		//compute median
		//
		if (cm.getState()) {
			medres = medcomp(myinputs);
		}
		//
		//compute trimmed
		//
		if (ct.getState()) {
			trimres = trimcomp(myinputs);
		}
		//
		//compute winsorized
		//
		if (cw.getState()) {
			winres = wincomp(myinputs);
		}
		//
		//compute cohen
		//
		if (cc.getState()) {
			cohenres = cohencomp(myinputs);
		}
		//
		//return
		//
		return true;
	}
	//
	//--- real computation ---
	//
	public double[] realcomp (double myinputs[][]) {
		//variables
		double data[];
		double total, mean, stdev, fail, temp;
		//computation
		fail = 0;
		data = myinputs[0];
		total = 0;
		for (int i = 0; i < datadim; i++) {
			if (data[i] == -1) {
				fail = 1;
			}
			if (data[i] == -2) {
				fail = 1;
			}
			total = total + data[i];
		}
		mean = total / datadim;
		temp = 0;
		for (int i = 0; i < datadim; i++) {
			temp = temp + Math.pow((data[i] - mean), 2);
		}
		stdev = Math.pow((temp / (datadim - 1)), 0.5);
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- zero computation ---
	//
	public double[] zerocomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double total, mean, stdev, fail, temp, dmod[];
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		dmod = new double[maxdim];
		total = 0;
		for (int i = 0; i < datadim; i++) {
			//check for blank
			if (data[i] == -1) {
				fail = 1;
			}
			//make modified data set
			dmod[i] = data[i];
			if (data[i] == -2) {
				dmod[i] = 0;
			}
			if ((! (ddl[i] < 0)) && (data[i] < ddl[i])) {
				dmod[i] = 0;
			}
			//sum total
			total = total + dmod[i];
		}
		mean = total / datadim;
		temp = 0;
		for (int i = 0; i < datadim; i++) {
			temp = temp + Math.pow((dmod[i] - mean), 2);
		}
		stdev = Math.pow((temp / (datadim - 1)), 0.5);
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- half computation ---
	//
	public double[] halfcomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double total, mean, stdev, fail, temp, dmod[];
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		dmod = new double[maxdim];
		total = 0;
		for (int i = 0; i < datadim; i++) {
			//check for blank
			if (data[i] == -1) {
				fail = 1;
			}
			//make modified data set
			dmod[i] = data[i];
			if (data[i] == -2) {
				dmod[i] = ddl[i] / 2;
			}
			if ((ddl[i] >= 0) && (data[i] < ddl[i])) {
				dmod[i] = ddl[i] / 2;
			}
			//sum total
			total = total + dmod[i];
		}
		mean = total / datadim;
		temp = 0;
		for (int i = 0; i < datadim; i++) {
			temp = temp + Math.pow((dmod[i] - mean), 2);
		}
		stdev = Math.pow((temp / (datadim - 1)), 0.5);
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- dl computation ---
	//
	public double[] dlcomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double total, mean, stdev, fail, temp, dmod[];
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		dmod = new double[maxdim];
		total = 0;
		for (int i = 0; i < datadim; i++) {
			//check for blank
			if (data[i] == -1) {
				fail = 1;
			}
			//make modified data set
			dmod[i] = data[i];
			if (data[i] == -2) {
				dmod[i] = ddl[i];
			}
			if ((ddl[i] >= 0) && (data[i] < ddl[i])) {
				dmod[i] = ddl[i];
			}
			//sum total
			total = total + dmod[i];
		}
		mean = total / datadim;
		temp = 0;
		for (int i = 0; i < datadim; i++) {
			temp = temp + Math.pow((dmod[i] - mean), 2);
		}
		stdev = Math.pow((temp / (datadim - 1)), 0.5);
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- delete computation ---
	//
	public double[] delcomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double total, mean, stdev, fail, temp, dmod[];
		int dim;
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		dmod = new double[maxdim];
		total = 0;
		dim = 0;
		for (int i = 0; i < datadim; i++) {
			//check for blank
			if (data[i] == -1) {
				fail = 1;
			}
			//make modified data set
			if (! ((data[i] == -2) || ((ddl[i] >= 0) && (data[i] < ddl[i])))) {
				dmod[dim] = data[i];
				total = total + dmod[dim];
				dim = dim + 1;
			}
		}
		mean = total / dim;
		temp = 0;
		for (int i = 0; i < dim; i++) {
			temp = temp + Math.pow((dmod[i] - mean), 2);
		}
		stdev = Math.pow((temp / (dim - 1)), 0.5);
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- median computation ---
	//
	public double[] medcomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double mean, fail;
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		mean = data[(int) (datadim / 2)];
		//check mean for balnk and BDL value
		if ((mean == -1) || (mean == -2)) {
			fail = 1;
		}
		//return
		double[] myresults = {mean, 0.0, fail};
		return myresults;
	}
	//
	//--- trimmed computation ---
	//
	public double[] trimcomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double total, mean, stdev, fail, temp, dmod[];
		int dim;
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		dmod = new double[maxdim];
		dim = 0;
		for (int i = 0; i < datadim; i++) {
			//check for blank
			if (data[i] == -1) {
				fail = 1;
			}
			//make modified data set
			if (! ((data[i] == -2) || ((ddl[i] >= 0) && (data[i] < ddl[i])))) {			
				dmod[dim] = data[i];
				dim = dim + 1;
			}
			if ((data[i] < ddl[i]) && (i >= (datadim / 2))) {
				fail = 1;
			}
		}
		dim = dim - (datadim - dim);
		total = 0;
		for (int i = 0; i < dim; i++) {
			total = total + dmod[i];
		}
		mean = total / dim;
		//return
		double[] myresults = {mean, 0.0, fail};
		return myresults;
	}
	//
	//--- winsorized computation ---
	//
	public double[] wincomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double total, mean, stdev, fail, temp, dmod[], lowval, highval, s, v;
		//computation
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		//check for blank
		for (int k = 0; k < datadim; k++) {
			if (data[k] == -1) {
				fail = 1;
			}
		}
		dmod = new double[maxdim];
		lowval = 0;
		int i = 0;
		while (lowval == 0) {
			//make modified data set
			if (! ((data[i] == -2) || ((ddl[i] >= 0) && (data[i] < ddl[i])))) {
				lowval = data[i];
			}
			i = i + 1;
			if (((data[i] == -2) || ((ddl[i] >= 0) && (data[i] < ddl[i]))) && (i >= (datadim / 2))) {
				fail = 1;
			}
		}
		highval = data[datadim - i];
		total = 0;
		for (int j = 0; j < datadim; j++) {
			if (j < i) {
				dmod[j] = lowval;
			}
			if ((j >= i) && (j <= (datadim - i))) {
				dmod[j] = data[j];
			}
			if (j > (datadim - i)) {
				dmod[j] = highval;
			}
			total = total + dmod[j];
		}
		mean = total / datadim;
		temp = 0;
		for (int j = 0; j < datadim; j++) {
			temp = temp + Math.pow((dmod[j] - mean), 2);
		}
		s = Math.pow((temp / (datadim - 1)), 0.5);
		v = datadim - (2 * (i - 1));
		stdev = (s * (datadim - 1)) / (v - 1);
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- cohen computation ---
	//
	public double[] cohencomp (double myinputs[][]) {
		//variables
		double data[], ddl[];
		double mean, stdev, fail;
		double sumyi, yb, sumdif, var, gamma, h, w, lnlambda, lambda;
		int n, nc, k;
		//computation
		mean = 0;
		stdev = 0;
		fail = 0;
		data = myinputs[0];
		ddl = myinputs[1];
		//check for single dl
		for (int i = 1; i < datadim; i++) {
			if (! (ddl[i - 1] == ddl[i])) {
				fail = 1;
			}
		}
		//cohen method
		if (fail == 0) {
			n = datadim;
			nc = 0;
			sumyi = 0;
			for (int i = 0; i < datadim; i++) {
				if (data[i] < ddl[0]) {
					nc = nc + 1;
				}
				if (! (data[i] < ddl[i])) {
					sumyi = sumyi + data[i];
				}
			}
			k = n - nc;
			yb = sumyi / k;
			sumdif = 0;
			for (int i = 0; i < datadim; i++) {
				if (! (data[i] < ddl[0])) {
					sumdif = sumdif + Math.pow((data[i] - yb), 2);
				}
			}
			var = sumdif / k;
			gamma = var / (Math.pow((yb - ddl[0]), 2));
			h = (((double) nc) / ((double) n));
			w = Math.log(h / (1 - h));
			lnlambda = 0.182344;
			lnlambda = lnlambda - (0.3756 / (gamma + 1));
			lnlambda = lnlambda + (0.10017 * gamma);
			lnlambda = lnlambda + (0.78079 * w);
			lnlambda = lnlambda - (0.00581 * Math.pow(gamma, 2));
			lnlambda = lnlambda - (0.06642 * Math.pow(w, 2));
			lnlambda = lnlambda - (0.0234 * gamma * w);
			lnlambda = lnlambda + (0.000174 * Math.pow(gamma, 3));
			lnlambda = lnlambda + (0.001663 * Math.pow(gamma, 2) * w);
			lnlambda = lnlambda - (0.00086 * gamma * Math.pow(w, 2));
			lnlambda = lnlambda - (0.00653 * Math.pow(w, 3));
			lambda = Math.pow(Math.E, lnlambda);
			mean = yb - (lambda * (yb - ddl[0]));
			stdev = Math.pow((var + (lambda * (Math.pow((yb - ddl[0]), 2)))), 0.5);
		}
		//return
		double[] myresults = {mean, stdev, fail};
		return myresults;
	}
	//
	//--- paint ---
	//
	public void paint(Graphics g) {
		//
		//method variables
		//
		double lowcut, highcut;
		//
		//upper right corner
		//
		offx = 230;
		offy = 75;
		axisx = 25;
		axisy = 25;
		//
		//get data dimensions
		//
		//lver.setText(String.valueOf(datadim));
		datamax = 0;
		for (int i = 0; i < datadim; i++) {
			if (ddv[i] > datamax) {
				datamax = ddv[i];
			}
		}
		//
		//coordinate system
		//
		//y-axis scaling:
		//1/20 data points @ axisy pixels
		//
		//x-axis scaling:
		//1/10 data max @ axisx pixels
		//
		g.setColor(Color.darkGray);
		g.drawLine((offx + 20), (offy + 20), (offx + 20), (offy + 300));
		g.drawString("f", (offx + 5), (offy + 28));
		g.drawLine((offx + 20), (offy + 300), (offx + 300), (offy + 300));
		g.drawString("value", (offx + 290), (offy + 314));
		for (int i = 0; i < 11; i++) {
			//x-axis
			g.drawLine((offx + 20 + i * axisx), (offy + 295), (offx + 20 + i * axisx), (offy + 305));
			g.drawString(String.valueOf(((double) ((int) (10 * (i * (datamax / 10))))) / 10) , (offx + 16 + i * axisx), (offy + 316));
			//y-axis
			g.drawLine((offx + 15), (offy + 300 - i * axisy) , (offx + 25), (offy + 300 - i * axisy));
			g.drawString(String.valueOf((((double) i) / 20)), (offx - 12), (offy + 305 - i * axisy));
		}
		//
		//data
		//
		count = 0;
		for (int i = 0; i < datadim; i++) {
			if (ddv[i] == -2) {
				count = count + 1;
			}
			g.fillRect((offx - 12 + (-1) * axisx), (int) (((double) offy) + 300 - (((double) count) * (20 / ((double) datadim))) * ((double) axisy)), (axisx), (int) ((((double) count) * (20 / ((double) datadim))) * ((double) axisy)));
		}
		if (count > 0) {
			g.drawString("BDL", (offx - 12 + (-1) * axisx),  (int) (((double) offy) + 295 - (((double) count) * (20 / ((double) datadim))) * ((double) axisy)));
		}
		breaks = 10;
		for (int j = 1; j <= (breaks + 1) ; j++) {
			lowcut = (double) (j - 1) * (datamax / breaks);
			highcut = (double) j * (datamax / breaks);
			count = 0;
			for (int i = 0; i < datadim; i++) {
				if ((ddv[i] >= lowcut) && (ddv[i] < highcut)) {
					count = count + 1;
				}
				g.fillRect((offx - 5 + j * axisx), (int) (((double) offy) + 300 - (((double) count) * (20 / ((double) datadim))) * ((double) axisy)), (axisx), (int) ((((double) count) * (20 / ((double) datadim))) * ((double) axisy)));
			}
		}
		//
		//detection limit(s)
		//
		g.setColor(Color.white);
		if (cdls.getState()) {
			g.drawLine((int) (offx + 20 + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 305), (int) (offx + 20 + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 20));
			g.drawLine((int) (offx + 19 + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 22), (int) (offx + 19 + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 20));
			g.drawLine((int) (offx + 21 + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 22), (int) (offx + 21 + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 20));
			g.drawString("DL", (int) (offx + (ddl[0] * ((double) axisx))), (offy + 35));
		}
		if (cdlm.getState()) {
			g.drawString("DL", (int) (offx + (ddl[0] * (10 / datamax) * ((double) axisx))), (offy + 35));
			for (int i = 0; i < datadim; i++) {
				if (! (ddl[i] < 0)) {
					g.drawLine((int) (offx + 20 + (ddl[i] * (10 / datamax) * ((double) axisx))), (offy + 305), (int) (offx + 20 + (ddl[i] * (10 / datamax) * ((double) axisx))), (offy + 20));
					g.drawLine((int) (offx + 19 + (ddl[i] * (10 / datamax) * ((double) axisx))), (offy + 22), (int) (offx + 19 + (ddl[i] * (10 / datamax) * ((double) axisx))), (offy + 20));
					g.drawLine((int) (offx + 21 + (ddl[i] * (10 / datamax) * ((double) axisx))), (offy + 22), (int) (offx + 21 + (ddl[i] * (10 / datamax) * ((double) axisx))), (offy + 20));
				}
			}
		}
		//
		//methods
		//
		mi = 0;
		//
		//real
		//
		if (cr.getState()) {
			plot(g, Color.black, realres, "Real", -10, mi);
			mi = mi + 1;
		}
		//
		//zero
		//
		if (cz.getState()) {
			plot(g, Color.blue, zerores, "Zero", -10, mi);
			mi = mi + 1;
		}
		//
		//half
		//
		if (ch.getState()) {
			plot(g, Color.cyan, halfres, "Half DL", -25, mi);
			mi = mi + 1;
		}
		//
		//dl
		//
		if (cd.getState()) {
			plot(g, Color.green, dlres, "DL", 0, mi);
			mi = mi + 1;
		}
		//
		//dx
		//
		if (cx.getState()) {
			plot(g, Color.magenta, delres, "Delete", -20, mi);
			mi = mi + 1;
		}
		//
		//dm
		//
		if (cm.getState()) {
			plot(g, Color.orange, medres, "Median", -25, mi);
			mi = mi + 1;
		}
		//
		//trimmed
		//
		if (ct.getState()) {
			plot(g, Color.pink, trimres, "Trimmed", -30, mi);
			mi = mi + 1;
		}
		//
		//dw
		//
		if (cw.getState()) {
			plot(g, Color.red, winres, "Winsorized", -48, mi);
			mi = mi + 1;
		}
		//
		//dc
		//
		if (cc.getState()) {
			plot(g, Color.yellow, cohenres, "Cohen", -20, mi);
			mi = mi + 1;
		}
	}
	//
	//--- data plot ---
	//
	public void plot(Graphics g, Color mycolor, double[] myresults, String desc, int offt, int mi) {
		//variables
		double mean, stdev, fail;
		//calculate
		mean = myresults[0];
		stdev = myresults[1];
		fail = myresults[2];
		g.setColor(mycolor);
		if (fail == 0) {
			g.drawLine((int) (((double) offx) + 20 + (mean * (10 / datamax) * ((double) axisx))), (offy + 305), (int) (((double) offx) + 20 + (mean * (10 / datamax) * ((double) axisx))), (offy + 45 + mi * axisy));
			g.drawLine((int) (((double) offx) + 19 + (mean * (10 / datamax) * ((double) axisx))), (offy + 47 + mi * axisy), (int) (offx + 19 + (mean * (10 / datamax) * ((double) axisx))), (offy + 45 + mi * axisy));
			g.drawLine((int) (((double) offx) + 21 + (mean * (10 / datamax) * ((double) axisx))), (offy + 47 + mi * axisy), (int) (offx + 21 + (mean * (10 / datamax) * ((double) axisx))), (offy + 45 + mi * axisy));
			String outstring = String.valueOf(((double) Math.rint(mean * 100)) / 100);
			if (stdev > 0) {
				g.drawLine((int) ((offx + 20 - (stdev * (10 / datamax) * ((double) axisx))) + (mean * (10 / datamax) * ((double) axisx))), (offy + 63 + mi * axisy), (int) (offx + 20 + (stdev * (10 / datamax) * ((double) axisx)) + (mean * (10 / datamax) * ((double) axisx))), (offy + 63 + mi * axisy));
				g.drawLine((int) ((offx + 20 - (stdev * (10 / datamax) * ((double) axisx))) + (mean * (10 / datamax) * ((double) axisx))), (offy + 62 + mi * axisy), (int) (offx + 22 - (stdev * (10 / datamax) * ((double) axisx)) + (mean * (10 / datamax) * ((double) axisx))), (offy + 62 + mi * axisy));
				g.drawLine((int) ((offx + 20 - (stdev * (10 / datamax) * ((double) axisx))) + (mean * (10 / datamax) * ((double) axisx))), (offy + 64 + mi * axisy), (int) (offx + 22 - (stdev * (10 / datamax) * ((double) axisx)) + (mean * (10 / datamax) * ((double) axisx))), (offy + 64 + mi * axisy));
				g.drawLine((int) ((offx + 18 + (stdev * (10 / datamax) * ((double) axisx))) + (mean * (10 / datamax) * ((double) axisx))), (offy + 62 + mi * axisy), (int) (offx + 20 + (stdev * (10 / datamax) * ((double) axisx)) + (mean * (10 / datamax) * ((double) axisx))), (offy + 62 + mi * axisy));
				g.drawLine((int) ((offx + 18 + (stdev * (10 / datamax) * ((double) axisx))) + (mean * (10 / datamax) * ((double) axisx))), (offy + 64 + mi * axisy), (int) (offx + 20 + (stdev * (10 / datamax) * ((double) axisx)) + (mean * (10 / datamax) * ((double) axisx))), (offy + 64 + mi * axisy));
				outstring = outstring + "/" + String.valueOf(((double) Math.rint(stdev * 100)) / 100);
			}
			g.drawString(desc, (int) (offx + offt + (mean * (10 / datamax) * ((double) axisx))), (offy + 60 + mi * axisy));
			g.drawString(outstring, (int) (offx + 24 + (mean * (10 / datamax) * ((double) axisx))), (offy + 60 + mi * axisy));
		}
		if (fail == 1) {
			g.drawString((desc + " failed"), (offx + 30), (offy + 60 + mi * axisy));
		}
	}
}
//
//-----------
//--- end ---
//-----------
//