/* JRG, the Resource Geology Seismic Processing System for Java,
   and Viewmat for Java are Copyright 1998-2007 by John N. Louie

License is hereby granted for anyone to make any use of this software and
its associated source and compiled binary codes, including free re-distribution,
and incorporation into commercial products, provided this copyright notice
is retained within all files, versions, and distribution media substantially
incorporating John Louie's original work.

The software and methods here are the subject of academic research,
not commercial products. I would like to know what use you make of
my methods, and have your feedback on their success or failure.
Also, by letting me know who you are, I can inform you if bugs or
errors are discovered.
 
Please send me an email message with: your name and email address;
whether you are a student or faculty member, consultant or employee;
the name of your university or company, and department; and a sentence
or two describing what use you intend to make of these methods.
Send your message to louie@seismo.unr.edu */


import java.util.*;
import java.io.*;
import java.lang.Math;
import java.awt.*;

class testvec
	{
	public static void main(String args[])
		{
		int i;
		System.out.println("Starting construction and reading.");
		FltVec fltvec = new FltVec(210*1000);
		
		/* read and write file test */
		fltvec.readBinaryFile("test.flt", 0);
		System.out.println("max=" + fltvec.max() + " rms=" + fltvec.rms()
			+ " dot=" + fltvec.dot(fltvec));
		
		/* dimensioning test
		System.out.println("" + fltvec.getNDims() + " dimensions of ");
		for (i=0; i<fltvec.getNDims(); i++)
			System.out.println("\t" + fltvec.getNMembofDim(0) + " elements.");
		*/
		 }
	}


public class FltVec implements RGData, RGNotice
	{
	public int NDims;
	public String AmpUnits;
	public float Amp0;
	public float AmpFac;
	public String ElemUnits;
	public float Elem0;
	public float DElem;
	public float vec[];
	public ViewmatFrame f;
	public boolean noticeon;
	
	public static float readIntelFloat(DataInputStream dis) throws IOException
		{
		int b1, b2, b3, b4;
		b1 = (int)(dis.readUnsignedByte());
		b2 = (int)(dis.readUnsignedByte());
		b3 = (int)(dis.readUnsignedByte());
		b4 = (int)(dis.readUnsignedByte());
		return Float.intBitsToFloat((b4 << 24) + (b3 << 16) + (b2 << 8) + b1);
		}
	public static int readIntelInt(DataInputStream dis) throws IOException
		{
		int b1, b2, b3, b4;
		b1 = (int)(dis.readUnsignedByte());
		b2 = (int)(dis.readUnsignedByte());
		b3 = (int)(dis.readUnsignedByte());
		b4 = (int)(dis.readUnsignedByte());
		return ((b2 << 24) | (b1 << 16) + (b4 << 8) + b3);
		}
	public static float readRAFIntelFloat(RandomAccessFile dis) throws IOException, EOFException
		{
		int b1, b2, b3, b4;
		b1 = (int)(dis.readUnsignedByte());
		b2 = (int)(dis.readUnsignedByte());
		b3 = (int)(dis.readUnsignedByte());
		b4 = (int)(dis.readUnsignedByte());
		return Float.intBitsToFloat((b4 << 24) + (b3 << 16) + (b2 << 8) + b1);
		}
	public static int readRAFIntelInt(RandomAccessFile dis) throws IOException, EOFException
		{
		int b1, b2, b3, b4;
		b1 = (int)(dis.readUnsignedByte());
		b2 = (int)(dis.readUnsignedByte());
		b3 = (int)(dis.readUnsignedByte());
		b4 = (int)(dis.readUnsignedByte());
		return ((b2 << 24) | (b1 << 16) + (b4 << 8) + b3);
		}

	public static Menu makeMethodsMenu()
		{
		Menu methods = new Menu("On Whole Data Set", true);
		methods.add(new MenuItem("absval"));
		methods.add(new MenuItem("add"));
		methods.add(new MenuItem("addc"));
		methods.add(new MenuItem("clip"));
		methods.add(new MenuItem("ctr"));
		methods.add(new MenuItem("cull"));
		methods.add(new MenuItem("dot"));
		methods.add(new MenuItem("hann"));
		methods.add(new MenuItem("inv"));
		methods.add(new MenuItem("log"));
		methods.add(new MenuItem("modulo"));
		methods.add(new MenuItem("mult"));
		methods.add(new MenuItem("multc"));
		methods.add(new MenuItem("neg"));
		methods.add(new MenuItem("sqrt"));
		methods.add(new MenuItem("square"));
		/* Add new FltVec methods below: */
		
		return methods;
		}
	public static void handleMethod(ViewmatFrame f, boolean inplace, String label)
		{
		f.setCursor(Cursor.WAIT_CURSOR);
		String title = f.vm.title + " + " + label;
		ViewmatAction vad = new ViewmatAction(f);
		vad.beginPanel();
		if (label.equals("absval"))
			FltVec.absvalPanel(vad, f, inplace, label);
		else if (label.equals("add"))
			FltVec.addPanel(vad, f, inplace, label);
		else if (label.equals("addc"))
			FltVec.addcPanel(vad, f, inplace, label);
		else if (label.equals("clip"))
			FltVec.clipPanel(vad, f, inplace, label);
		else if (label.equals("ctr"))
			FltVec.ctrPanel(vad, f, inplace, label);
		else if (label.equals("cull"))
			FltVec.cullPanel(vad, f, inplace, label);
		else if (label.equals("dot"))
			FltVec.dotPanel(vad, f, inplace, label);
		else if (label.equals("hann"))
			FltVec.hannPanel(vad, f, inplace, label);
		else if (label.equals("inv"))
			FltVec.invPanel(vad, f, inplace, label);
		else if (label.equals("log"))
			FltVec.logPanel(vad, f, inplace, label);
		else if (label.equals("modulo"))
			FltVec.moduloPanel(vad, f, inplace, label);
		else if (label.equals("mult"))
			FltVec.multPanel(vad, f, inplace, label);
		else if (label.equals("multc"))
			FltVec.multcPanel(vad, f, inplace, label);
		else if (label.equals("neg"))
			FltVec.negPanel(vad, f, inplace, label);
		else if (label.equals("sqrt"))
			FltVec.sqrtPanel(vad, f, inplace, label);
		else if (label.equals("square"))
			FltVec.squarePanel(vad, f, inplace, label);
		/* Add new FltVec methods below: */
		
		if (inplace)
			vad.setTitle(label + " on " + f.getTitle() + " in-place");
		else
			vad.setTitle(label + " on " + f.getTitle() + " to new window");
		Button apply = new Button(label);
		vad.pp.add(apply);
		apply.addActionListener(vad);
		vad.finishPanel();
		f.setCursor(Cursor.DEFAULT_CURSOR);
		vad.center();
		vad.show();
		if (vad.done == false)
			{
			vad.dispose();
			return;
			}
		f.setCursor(Cursor.WAIT_CURSOR);
		FltVec fv = null;
		FltVec ofv = null;
		MethodRun mrun = null;
		if (vad.noticeonly == true)
			{
			if (f.vm.fvol == null)
				fv = f.vm.fp;
			else
				fv = f.vm.fvol;
			}
		else if (inplace)
			{
			if (f.vm.fvol == null)
				{
				ofv = f.vm.fp;
				fv = new FltVec(f.vm.fp, f.vm.fp.vec);
				}
			else
				{
				ofv = f.vm.fvol;
				fv = new FltVec(f.vm.fvol, f.vm.fvol.vec);
				}
			}
		else
			{
			if (f.vm.fvol == null)
				{
				mrun = new MethodRun(f.vm.fp, f.fd.getDirectory(),
					title, f.vm.rowsdown,
					f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
				ofv = mrun.fp;
				fv = new FltVec(mrun.fp, mrun.fp.vec);
				}
			else
				{
				mrun = new MethodRun(f.vm.fvol, f.fd.getDirectory(),
					title, f.vm.rowsdown,
					f.vm.ve, f.vm.ctab, f.vm.positive, f.vm.clip);
				ofv = mrun.fvol;
				fv = new FltVec(mrun.fvol, mrun.fvol.vec);
				}
			}
		if (label.equals("absval"))
			fv.absval();
		else if (label.equals("add"))
			fv.doadd(vad);
		else if (label.equals("addc"))
			fv.doaddc(vad);
		else if (label.equals("clip"))
			fv.doclip(vad);
		else if (label.equals("ctr"))
			fv.ctr();
		else if (label.equals("cull"))
			fv.docull(vad);
		else if (label.equals("dot"))
			fv.dodot(vad);
		else if (label.equals("hann"))
			fv.dohann(vad);
		else if (label.equals("inv"))
			fv.inv();
		else if (label.equals("log"))
			fv.log();
		else if (label.equals("modulo"))
			fv.domodulo(vad);
		else if (label.equals("mult"))
			fv.domult(vad);
		else if (label.equals("multc"))
			fv.domultc(vad);
		else if (label.equals("neg"))
			fv.neg();
		else if (label.equals("sqrt"))
			fv.dosqrt(vad);
		else if (label.equals("square"))
			fv.dosquare(vad);
		/* Add new FltVec methods below: */
		
		if (vad.noticeonly == true)
			{
			vad.dispose();
			f.setCursor(Cursor.DEFAULT_CURSOR);
			return;
			}
		vad.dispose();
		ofv.copyvals(fv);
		if (inplace)
			{
			f.setTitle(title);
			f.props.setTitle(title + " Properties");
			f.vm.titletf.setText(title);
			/*f.vm.cvs.vmat.clip = f.vm.fp.max();*/
			f.vm.cvs.vmat.title = new String(title);
			if (f.vm.fvol == null)
				f.vm.fp.replotinFrame(f);
			else
				f.vm.fvol.replotinFrame(f);
			f.vm.cvs.zoom(f.vm.fzoom);
			}
		else
			/* altered 3/1/06 JNL to workaround MacOS 10.4 bug
			   thanks to Leiph Preston!
			new Thread(mrun).start();
			*/
			mrun.run();
		f.setCursor(Cursor.DEFAULT_CURSOR);
		return;
		}
	static void setupReadBinaryFile(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		setupReadBinaryFile(vad, f, inplace, label, true);
		}
	static void setupReadBinaryFile(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label, boolean Equal)
		{
		if (f.vm.fvol == null)
			{
			vad.lab1 = new Label("(" + f.vm.fp.getNMembofDim(0)
			+ "-element by " + f.vm.fp.getNMembofDim(1)
			+ "-vector Plane):");
			vad.nametf = new TextField("plane.flt", 16);
			}
		else
			{
			vad.lab1 = new Label("(" + f.vm.fvol.getNMembofDim(0)
			+ "-elem. by " + f.vm.fvol.getNMembofDim(1)
			+ "-vec. by " + f.vm.fvol.getNMembofDim(2)
			+ "-plane Volume):");
			vad.nametf = new TextField("volume.flt", 16);
			}
		Label tlab1 = new Label("Binary File Type:");
		vad.pp.add(tlab1);
		vad.bintype = vad.makeBintype(true);
		vad.pp.add(vad.bintype);
		vad.bintype.select(1);		
		vad.bintype.addItemListener(vad);
		vad.firstreclab = new Label("First Field Record No. to Read:");
		vad.pp.add(vad.firstreclab);
		vad.firstrectf = new TextField("", 4);
		vad.pp.add(vad.firstrectf);
		vad.lastreclab = new Label("Last:");
		vad.pp.add(vad.lastreclab);
		vad.lastrectf = new TextField("", 4);
		vad.pp.add(vad.lastrectf);
		vad.tapeheadcb = new Checkbox("3600-byte Reel Header Block Present");
		vad.pp.add(vad.tapeheadcb);
		vad.tapeheadcb.setState(true);
		vad.samptypelab = new Label("Trace Data Type:");
		vad.pp.add(vad.samptypelab);
		vad.samptypech = new Choice();
		vad.samptypech.add("IEEE/Java Float");
		vad.samptypech.add("IBM Float");
		vad.samptypech.add("32-bit Integer");
		vad.samptypech.add("16-bit Integer");
		vad.samptypech.add("32-bit Int w/ Gain");
		vad.pp.add(vad.samptypech);
		vad.samptypech.select(0);
		/*
		vad.swabheadcb = new Checkbox("Must Byte-Swap Binary in Headers");
		vad.pp.add(vad.swabheadcb);
		vad.swabheadcb.setState(false);
		*/
		vad.getfile = new Button("Get File...");
		vad.pp.add(vad.lab1);
		vad.namelab = new Label("Binary File Name:");
		vad.pp.add(vad.namelab);
		vad.pp.add(vad.getfile);
		vad.getfile.addActionListener(vad);
		vad.pp.add(vad.nametf);
		vad.skiplab = new Label("Bytes to Skip:");
		vad.pp.add(vad.skiplab);
		vad.skiptf = new TextField("0", 8);
		vad.pp.add(vad.skiptf);
		if (!Equal)
			{
			vad.nelab = new Label("Elements per Vector:");
			vad.pp.add(vad.nelab);
			if (f.vm.fvol == null)
				vad.netf = new TextField("" + f.vm.fp.getNMembofDim(0), 5);
			else
				vad.netf = new TextField("" + f.vm.fvol.getNMembofDim(0), 5);
			vad.pp.add(vad.netf);
			vad.nvlab = new Label("Vectors per Plane:");
			vad.pp.add(vad.nvlab);
			if (f.vm.fvol == null)
				vad.nvtf = new TextField("" + f.vm.fp.getNMembofDim(1), 5);
			else
				vad.nvtf = new TextField("" + f.vm.fvol.getNMembofDim(1), 5);
			vad.pp.add(vad.nvtf);
			vad.nplab = new Label("Number of Planes:");
			vad.pp.add(vad.nplab);
			if (f.vm.fvol == null)
				vad.nptf = new TextField("1", 5);
			else
				vad.nptf = new TextField("" + f.vm.fvol.getNMembofDim(2), 5);
			vad.pp.add(vad.nptf);
			}
		vad.rgtype = new Checkbox("Old RG headers without source coords.");
		vad.pp.add(vad.rgtype);
		vad.rgtype.setState(true);
		vad.rgtype.setEnabled(false);
		if (Equal)
			vad.height = 500;
		else
			vad.height = 550;
		vad.setSize(300, vad.height);
		vad.skiplab.setEnabled(false);
		vad.skiptf.setEnabled(false);
		if (vad.nelab != null)
			{
			vad.nelab.setEnabled(false);
			vad.netf.setEnabled(false);
			vad.nvlab.setEnabled(false);
			vad.nvtf.setEnabled(false);
			vad.nplab.setEnabled(false);
			vad.nptf.setEnabled(false);
			}
		vad.rgtype.setEnabled(false);
		}
	public FltPlane readEqualFile(ViewmatAction vad)
		{
		return readEqualFile(vad, true);
		}
	public FltPlane readEqualFile(ViewmatAction vad, boolean Equal)
		{
		vad.readtype = vad.bintype.getSelectedIndex();
		String path = vad.nametf.getText();
		int skip = 0;
		int ne, nv, np;
		FltPlane fp;
		SEGYFileHead sfhd;
		RgHead rghd[];
		long addresses[];
		RgFileHead fhd;
		int samptype;
		Long temp;
		if (vad.readtype == 1) /* SEG-Y */
			{
			fhd = vad.checkReadBinary(vad.nametf.getText());
			if (fhd.isValid())
				addresses = new long[vad.sfhd.addresses.size()];
			else if (vad.firstrec < 0 && vad.lastrec < 0)
				{
				this.f.Errout("File " + path
				+ "\ndoes not appear to be a SEG-Y file:\n"
				+ fhd);
				return null;
				}	
			else if (vad.firstrec < 0 && vad.lastrec > -1)
				{
				this.f.Errout("File " + path
				+ "\ndoes not appear to be a SEG-Y file,\n"
				+ "or does not include record numbers <= " + vad.lastrec + ":\n"
				+ fhd);
				return null;
				}	
			else if (vad.firstrec > -1 && vad.lastrec < 0)
				{
				this.f.Errout("File " + path
				+ "\ndoes not appear to be a SEG-Y file,\n"
				+ "or does not include record numbers >= " + vad.firstrec + ":\n"
				+ fhd);
				return null;
				}	
			else
				{
				this.f.Errout("File " + path
				+ "\ndoes not appear to be a SEG-Y file,\n"
				+ "or does not include record numbers " + vad.firstrec
				+ " through " + vad.lastrec + ":\n"
				+ fhd);
				return null;
				}
			if (Equal && (this.vec.length != fhd.ntrace*fhd.nt))
				{
				Errout("Selected records in SEG-Y file " + vad.nametf.getText()
				+ "\nhave " + (fhd.ntrace*fhd.nt) + " samples total but "
				+ "current data has " + this.vec.length + ",\n"
				+ "cannot use the records as a size equivalent.");
				return null;
				}
			for (int i=0; i<addresses.length; i++)
				{
				temp = (Long)(vad.sfhd.addresses.elementAt(i));
				addresses[i] = temp.longValue();
				}
			rghd = new RgHead[vad.sfhd.headers.size()];
			for (int i=0; i<rghd.length; i++)
				rghd[i] = new RgHead((RgHead)(vad.sfhd.headers.elementAt(i)));
			fp = new FltPlane(fhd.ntrace, fhd.nt);
			fp.headers = rghd;
			samptype = vad.samptype;
			fp.readSEGYFile(path, addresses, samptype);
			}
		else if (vad.readtype == 2) /* RG */
			{
			vad.oldrg = vad.rgtype.getState();
			fhd = vad.checkReadBinary(vad.nametf.getText());
			if (fhd.isValid() != true)
				{
				Errout("File " + vad.nametf.getText()
				+ "\ndoes not appear to have an RG file header:\n"
				+ fhd);
				return null;
				}
			if (Equal && (this.vec.length != fhd.ntrace*fhd.nt))
				{
				Errout("RG file " + vad.nametf.getText()
				+ "\nhas " + (fhd.ntrace*fhd.nt) + " samples total but "
				+ "current data has " + this.vec.length + ",\n"
				+ "cannot use the file as a size equivalent.");
				return null;
				}
			fp = new FltPlane(fhd.ntrace, fhd.nt);
			fp.readRGFile(vad.nametf.getText(), vad.oldrg);
			}
		else if (vad.readtype == 12 || vad.readtype == 13) /* SAC */
			{
			fhd = vad.checkReadBinary(vad.nametf.getText());
			if (fhd.isValid() != true)
				{
				Errout("File " + vad.nametf.getText()
				+ "\ndoes not appear to have a SAC trace header:\n"
				+ fhd);
				return null;
				}
			if (Equal && (this.vec.length != fhd.ntrace*fhd.nt))
				{
				Errout("SAC file " + vad.nametf.getText()
				+ "\nhas " + (fhd.ntrace*fhd.nt) + " samples total but "
				+ "current data has " + this.vec.length + ",\n"
				+ "cannot use the file as a size equivalent.");
				return null;
				}
			fp = new FltPlane(fhd.ntrace, fhd.nt);
			SACTraceHead.readSACFiletoFP(fp, vad.nametf.getText(),
				fhd, (vad.readtype==13 ? true : false));
			}
		else /* Raw */
			{
			try {skip = Integer.valueOf(vad.skiptf.getText()).intValue(); }
			catch (NumberFormatException nfe)
				{skip = 0; }
			if (skip < 0)
				skip = 0;
			if (Equal)
				fp = new FltPlane(this.getNMembofDim(2)*this.getNMembofDim(1),
					this.getNMembofDim(0));
			else
				{
				try {ne = Integer.valueOf(vad.netf.getText()).intValue(); }
				catch (NumberFormatException nfe)
					{ne = this.getNMembofDim(0); }
				if (ne <= 0)
					ne = this.getNMembofDim(0);
				try {nv = Integer.valueOf(vad.nvtf.getText()).intValue(); }
				catch (NumberFormatException nfe)
					{nv = this.getNMembofDim(1); }
				if (nv <= 0)
					nv = this.getNMembofDim(1);
				try {np = Integer.valueOf(vad.nptf.getText()).intValue(); }
				catch (NumberFormatException nfe)
					{np = this.getNMembofDim(2); }
				if (np <= 0)
					np = this.getNMembofDim(2);
				vad.iv1 = ne;
				vad.iv2 = nv;
				vad.iv3 = np;
				fp = new FltPlane(vad.iv3*vad.iv2, vad.iv1);	
				}
			fp.readBinaryFile(vad.nametf.getText(), skip, vad.readtype);
			}
		return fp;
		}
	
	/* put implementations of new FltVec methods below: */
	
	public void absval()
		{
		int i;
		float val;
		Notice("absval: taking absolute value of "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			/*vec[i] = Math.abs(vec[i]);*/
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			vec[i] = val < 0.0F ? -val : val;
			}
		Noticeln("done.");
		}
	static void absvalPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "computes the absolute value"
			+ "of each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		}
		
	public void add(FltVec fv)
		{
		int i;
		if (this.vec.length != fv.vec.length)
			{
			Errout("add: cannot add FltVec with length "
			+ fv.vec.length + " to existing FltVec of length "
			+ this.vec.length);
			return;
			}
		Notice("add: adding two arrays of "
			+ this.vec.length + " elements... ");
		for (i=0; i<this.vec.length; i++)
			this.vec[i] += fv.vec[i];
		this.Amp0 += fv.Amp0;
		Noticeln("done.");
		}
	static void addPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "adds corresponding elements of the\n"
			+ "selected file to the current data.",
			5, 35);
		vad.pp.add(vad.expl);
		setupReadBinaryFile(vad, f, inplace, label);
		}
	public void doadd(ViewmatAction vad)
		{
		FltPlane fp = readEqualFile(vad);
		if (fp == null)
			{
			Errout("Could not add the selected file to the current data.");
			return;
			}
		this.add(fp);
		fp = null;
		}
		
	public void addc(float cons)
		{
		int i;
		Notice("addc: adding constant " + cons + " to "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			vec[i] += cons;
		this.Amp0 -= cons;
		Noticeln("done.");
		}
	public void addc(double cons)
		{
		this.addc((float)(cons));
		}
	static void addcPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "adds the constant float value below\n"
			+ "to each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Const. Value (can be negative):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("0.0", 8);
		vad.pp.add(vad.tf0);
		}
	public void doaddc(ViewmatAction vad)
		{
		float temp=0F;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("Cannot add entered value of " + vad.tf0.getText());
			return;
			}
		this.addc(temp);
		}
		
	/* modified after SEP and J. Claerbout by J. Louie, 1999 */
	public void agc(int Elem0, int NElem, int Window,
		boolean Detect, int DetectWindow, float Threshold)
		{
		int i, start, end, xp, yp, tail, head;
		float probe, l1norm, oldnorm;
		int window = Window;
		if (window > NElem)
			window = NElem;
		int dwind = DetectWindow;
		int nt = NElem;
		float thresh = Threshold;
		float vy[] = new float[NElem];
		int x = Elem0;
		int y = 0;
		xp = x; yp = y;
		/* detect first significant energy by comparing 
		   short moving window with an initial average */
		if (Detect)
			{
			xp = this.agcdetects(Elem0, NElem, Window, Detect,
				DetectWindow, Threshold, vy);
			yp = xp - x;
			if (xp < 0)
				{
				vy = null;
				return;
				}
			}
		/* untaper beginning of trace */
		for (start = xp, l1norm = 0F, end = xp + window;
			xp<end && xp<this.vec.length;)
			{
			if (this.vec[xp]>0F) l1norm += this.vec[xp];
			else l1norm -= this.vec[xp];
			xp++;
			}
		if (l1norm == 0) 
			{
			xp = this.agcdetects(Elem0, NElem, Window, Detect,
				DetectWindow, Threshold, vy);
			yp = xp - x;
			if (xp < 0)
				{
				vy = null;
				return;
				}
			for (start = xp, l1norm = 0F, end = xp + window;
				xp<end && xp<this.vec.length;)
				{
				if (this.vec[xp]>0F) l1norm += this.vec[xp];
				else l1norm -= this.vec[xp];
				xp++;
				}
			}
		if (l1norm == 0) 
			{
			vy = null;
			return;
			}
		for (xp = start, end = start + window / 2; xp<end;)
			{
			vy[yp] = this.vec[xp] / l1norm;
			yp++;
			xp++;
			}
		/* core routine */
		for (tail = start, head = start + window-1, end = x + nt - window / 2,
			oldnorm = l1norm; xp<end;)
			{
			if (this.vec[head]>0F) l1norm += this.vec[head];
			else l1norm -= this.vec[head];
			head++;
			if (this.vec[tail]>0F) l1norm -= this.vec[tail];
			else l1norm += this.vec[tail];
			tail++;
			if (oldnorm == 0F) l1norm = oldnorm;
			oldnorm = l1norm;
			vy[yp] = this.vec[xp] / l1norm;
			yp++;
			xp++;
			}

		/* untaper end of trace */
		for (end = x + nt; xp<end;)
			{
			vy[yp] = this.vec[xp] / l1norm;
			yp++;
			xp++;
			}
		System.arraycopy(vy, 0, this.vec, Elem0, NElem);
		vy = null;
		}
	public int agcdetects(int Elem0, int NElem, int Window,
		boolean Detect, int DetectWindow, float Threshold, float vy[])
		{
		int i, end, xp, yp, tail, head;
		float probe;
		int dwind = DetectWindow;
		int nt = NElem;
		float thresh = Threshold;
		int x = Elem0;
		int y = 0;
		xp = x; yp = y;
		/* detect first significant energy by comparing 
		   short moving window with an initial average */
		for (end = y + nt; yp<end;)
			{
			vy[yp] = 0F;
			yp++;
			}
		float initaver = 0F;
		for (end = x+dwind; xp<end && xp<this.vec.length;)
			{
			if (this.vec[xp] > 0F) initaver += this.vec[xp];
			else initaver -= this.vec[xp];
			xp++;
			}
		for (xp = x + dwind / 2, yp = y + dwind / 2, tail = x,
			head = x + dwind, end = x + nt - dwind / 2, probe = initaver;
			((probe<=(initaver*thresh)) && (xp<end)); xp++, yp++)
			{
			if (this.vec[head]>0F) probe += this.vec[head];
			else probe -= this.vec[head];
			head++;
			if (this.vec[tail]>0F) probe -= this.vec[tail];
			else probe += this.vec[tail];
			tail++;
			}
		if ((xp == end)||(probe == 0F))
			return -1;
		return xp;
		}
		
	public void clip(float lim1, float lim2)
		{
        	int i;
        	float hold;
		if (lim1 > lim2)
               	{
               	hold = lim1;
               	lim1 = lim2;
               	lim2 = hold;
               	}
        	Notice("clip: clipping " + vec.length + " elements to between "
        		+ lim1 + " and " + lim2 + "... ");
		for (i=0; i<vec.length; i++)
                      {
                      hold = vec[i];
                      if (hold > lim2)
                              vec[i] = lim2;
                      else if (hold < lim1)
                              vec[i] = lim1;
                      }
               Noticeln("done.");
		}
       public void clip(double lim1, double lim2)
       		{ this.clip((float)(lim1), (float)(lim2)); }
       static void clipPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "irreversibly replaces amplitudes less than the\n"
			+ "first limit below with with the limit, and\n"
			+ "those above the second limit below with that\n"
			+ "limit. (Default limits that appear below are the\n"
			+ "signed minimum and maximum.) Plots can be\n"
			+ "clipped temoprarily using the Clip value in\n"
			+ "the Edit->Plot Parameters dialogue.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Low Clip (positive or negative):");
		vad.lab1 = new Label("High Clip (positive or negative):");
		if (f.vm.fvol == null)
			{
			vad.tf0 = new TextField("" + f.vm.fp.smin(), 8);
			vad.tf1 = new TextField("" + f.vm.fp.max(), 8);
			}
		else
			{
			vad.tf0 = new TextField("" + f.vm.fvol.smin(), 8);
			vad.tf1 = new TextField("" + f.vm.fvol.max(), 8);
			}
		vad.pp.add(vad.lab0);
		vad.pp.add(vad.tf0);
		vad.pp.add(vad.lab1);
		vad.pp.add(vad.tf1);
		}
	public void doclip(ViewmatAction vad)
		{
		float ltemp=Float.MAX_VALUE;
		try {ltemp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("Cannot clip with entered low of " + vad.tf0.getText());
			return;
			}
		float htemp=Float.MAX_VALUE;
		try {htemp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("Cannot clip with entered high of " + vad.tf1.getText());
			return;
			}
		this.clip(ltemp, htemp);
		}
			
       	public void ctr()
       		{
		float avg;
		int i;
		avg = 0.0F;
              	Notice("FltVec.ctr: removing average ");
              	for (i=0; i<vec.length; i++)
			avg += vec[i];
		avg /= (float)(vec.length);
		Notice("of " + avg + " from " + vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
 			{
			vec[i] -= avg;
			}
		this.Amp0 = avg;
		Noticeln("done.");
		}
	public void demean()
		{this.ctr(); }
	static void ctrPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "subtracts the data set's arithmetic mean\n"
			+ "from each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		}
		
	public void cull(float limit)
       		{
		int i, count;
		float val;
		count = 0;
		Notice("cull: zeroing values larger than " + limit + " from "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			val = vec[i];
			val = val < 0.0F ? -val : val;
			/* Comparison changed 5/7/93 to avoid passing
			NaNs untouched due to Unordered result of
			comparison */
			if (!(val < limit))
				{
				vec[i] = 0.0F;
				count++;
				}
			}
		if (count > 0)
			Errout("cull: " + count + " elements over " + limit + " found");
		Noticeln("done.");
		}
	public void cull()
		{this.cull(Float.MAX_VALUE); }
	static void cullPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "replaces positive or negative amplitudes greater\n"
			+ "than or equal to the limit below with zero.\n"
			+ "Values of NaN and Inf are also zeroed.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Cull Limit Value (positive):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("" + Float.MAX_VALUE, 8);
		vad.pp.add(vad.tf0);
		}
	public void docull(ViewmatAction vad)
		{
		float temp=Float.MAX_VALUE;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("Cannot cull with entered limit of " + vad.tf0.getText());
			return;
			}
		this.cull(temp);
		}
			
	public double dot(FltVec f1)
		{
		int i;
		double sum;
		sum = 0.0;
		Notice("dot: finding product of two arrays of "
			+ this.vec.length + " elements... ");
		for (i=0; i<this.vec.length; i++)
			sum += this.vec[i] * f1.vec[i];
		Noticeln("done.");
		return sum;
		}
	static void dotPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "finds the dot product value of the\n"
			+ "selected file against the current data.",
			5, 35);
		vad.pp.add(vad.expl);
		setupReadBinaryFile(vad, f, inplace, label);
		vad.noticeonly = true;
		}
	public void dodot(ViewmatAction vad)
		{
		FltPlane fp = readEqualFile(vad);
		if (fp == null)
			{
			Errout("Could not dot-product the selected file against the current data.");
			return;
			}
		ViewmatNotice vn = new ViewmatNotice(vad.f,
			vad.f.getTitle() + " dot " + vad.nametf.getText(),
			"" + this.vec.length + "-element dot product = "
			+ this.dot(fp) );
		vn.show();
		fp = null;
		}
	
       	public void hann(float Portion, float Rise)
       		{
		int n, nt;
		double hold;
		nt = this.vec.length;
              	if(nt < 4)
			{
			Errout("hann: NElem=" + nt + " is < 4, cannot taper.");
			return;
			}
		Notice("FltVec.hann: " + (100F*Portion) + "% tapering with "
			+ 100F*Rise + "% raised cosine... ");
		for(n=0; n<(int)(Portion*nt/2.0); n++)
			{
			hold = Math.cos(n*2.0*Math.PI/(double)(Portion*(nt-1)) - Math.PI);
			this.vec[n] *= (float)(0.5 + Rise + (0.5 - Rise)*hold);
			}
		for(n=(int)(nt - Portion*nt/2.0); n<nt; n++)
			{
			hold = Math.cos((n-(int)((1F-Portion)*nt))*2.0*Math.PI
				/(double)(Portion*(nt-1)) - Math.PI);
			this.vec[n] *= (float)(0.5 + Rise + (0.5 - Rise)*hold);
			}
		Noticeln("done.");
		}
       	public void hann()
       		{
		hann(1F, 0.05F);
		}
	static void hannPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "tapers the element amplitudes at the ends by\n"
			+ "applying a raised cosine Hanning window.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Taper Portion (float, >0.0, <=1.0):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("1.0", 4);
		vad.pp.add(vad.tf0);
		vad.lab1 = new Label("Rise (float, >=0.0, <0.5):");
		vad.pp.add(vad.lab1);
		vad.tf1 = new TextField("0.05", 4);
		vad.pp.add(vad.tf1);
		}
	public void dohann(ViewmatAction vad)
		{
		float temp, portion, rise;
		portion = 1F;
		rise = 0.05F;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("hann: Cannot taper with portion of "
				+ vad.tf0.getText() + " - must be a positive float <= 1.0.");
			return;
			}
		if (temp <= 0F || temp > 1F)
			{
			Errout("hann: Cannot taper with portion of "
				+ vad.tf0.getText() + " - must be a positive float <= 1.0.");
			return;
			}
		portion = temp;
		try {temp = Float.valueOf(vad.tf1.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("hann: Cannot taper with rise of "
				+ vad.tf1.getText() + " - must be a positive float < 0.5.");
			return;
			}
		if (temp < 0F || temp >= 0.5F)
			{
			Errout("hann: Cannot taper with rise of "
				+ vad.tf1.getText() + " - must be a positive float < 0.5.");
			return;
			}
		rise = temp;
		this.hann(portion, rise);
		}
		
       	public void inv()
       		{
		int i;
		float hold;
              	Notice("FltVec.inv: inverting amplitudes of "
              		+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			hold = vec[i];
			if (hold == 0F)
				vec[i] = 0F;
			else
				vec[i] = 1F/hold;
			}
		/*
		if (this.AmpFac != 0F)
			this.AmpFac = 1F/this.AmpFac;
		*/
		this.AmpUnits = new String("Inverse " + this.AmpUnits);
		Noticeln("done.");
		}
	static void invPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "inverts (divides 1.0 by) each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		}
		
       	public void log()
       		{
		int i;
		float hold;
		double log10;
		log10 = Math.log(10.0);
              	Notice("FltVec.log: taking log of " + vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			hold = vec[i];
			if (hold <= 0F)
				vec[i] = 0F;
			else
				vec[i] = (float)(Math.log(hold)/log10);
			}
		this.Amp0 = 0F;
		this.AmpFac = 1F;
		this.AmpUnits = new String("Log10 " + this.AmpUnits);
		Noticeln("done.");
		}
	static void logPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "finds the log, base 10, of each element's amplitude.\n"
			+ "Negative and zero amplitudes become zero.",
			5, 35);
		vad.pp.add(vad.expl);
		}
		
	public void modulo(float cons)
		{
		int i, dval;
		float val;
		if (cons <= 0F)
			{
			Errout("FltVec.modulo: can't find modulo " + cons
			+ ", must supply positive float value.");
			return;
			}
		Notice("FltVec.modulo: finding modulo " + cons + " of "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			dval = (int)(val/cons);
			vec[i] -= (float)(dval)*cons;
			}
		this.Amp0 = 0F;
		this.AmpUnits = new String(this.AmpUnits + " Modulo " + cons);
		Noticeln("done.");
		}
	public void modulo(double cons)
		{
		this.modulo((float)(cons));
		}
	static void moduloPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "produces the modulo, relative to a positive\n"
			+ "float value, of each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Modulo by (pos. float):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("1.0", 8);
		vad.pp.add(vad.tf0);
		}
	public void domodulo(ViewmatAction vad)
		{
		float temp=1F;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("modulo: Cannot find modulo by entered value of "
				+ vad.tf0.getText() + " - must be a positive float number.");
			return;
			}
		if (temp == 0F)
			{
			Errout("modulo: Cannot find modulo by entered value of "
				+ vad.tf0.getText() + " - must be a positive float number.");
			return;
			}
		else if (temp < 0F)
			temp = -temp;
		this.modulo(temp);
		}
		
	public void mult(FltVec fv)
		{
		int i;
		if (this.vec.length != fv.vec.length)
			{
			Errout("mult: cannot multiply FltVec with length "
			+ fv.vec.length + " by existing FltVec of length "
			+ this.vec.length);
			return;
			}
		Notice("mult: multiplying two arrays of "
			+ this.vec.length + " elements... ");
		for (i=0; i<this.vec.length; i++)
			this.vec[i] *= fv.vec[i];
		this.AmpFac *= fv.AmpFac;
		this.AmpUnits = new String(this.AmpUnits + " times " + fv.AmpUnits);
		Noticeln("done.");
		}
	static void multPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "multiplies corresponding elements of the\n"
			+ "selected file by the current data.",
			5, 35);
		vad.pp.add(vad.expl);
		setupReadBinaryFile(vad, f, inplace, label);
		}
	public void domult(ViewmatAction vad)
		{
		FltPlane fp = readEqualFile(vad);
		if (fp == null)
			{
			Errout("Could not multiply the selected file against the current data.");
			return;
			}
		this.mult(fp);
		fp = null;
		}
		
	public void multc(float cons)
		{
		int i;
		Notice("addc: multiplying constant " + cons + " against "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			vec[i] *= cons;
		/*this.Amp0 *= cons;*/
		this.AmpFac /= cons;
		Noticeln("done.");
		}
	public void multc(double cons)
		{
		this.multc((float)(cons));
		}
	static void multcPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "multiplies the constant float value below\n"
			+ "against each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.lab0 = new Label("Const. Value (can be negative):");
		vad.pp.add(vad.lab0);
		vad.tf0 = new TextField("1.0", 8);
		vad.pp.add(vad.tf0);
		}
	public void domultc(ViewmatAction vad)
		{
		float temp=1F;
		try {temp = Float.valueOf(vad.tf0.getText()).floatValue(); }
		catch (NumberFormatException nfe)
			{
			Errout("multc: Cannot multiply by entered value of "
				+ vad.tf0.getText() + " - must be a float number.");
			return;
			}
		this.multc(temp);
		}
		
       	public void neg()
       		{
		int i;
			Notice("FltVec.neg: negating amplitudes of "
              		+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			vec[i] *= -1F;
			}
		this.Amp0 = 0F /* *= -1F */;
		this.AmpFac *= -1F;
		Noticeln("done.");
		}
	static void negPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "negates (multiplies by -1.0) each element's amplitude.",
			5, 35);
		vad.pp.add(vad.expl);
		}
		
	/* From Claerbout, Stanford Exploration Project
	quantile of absolute values-finding subroutine.  See SEP 10 p. 99-100.
	*/
	public static float quant(int iq, float x[], int nsamp)
		{
		int hi, low, i, j;
		float temp, xk;
		low = 0;
		hi = nsamp-1;
		while (low < hi)
	 		{
			xk = x[iq]<0 ? -x[iq] : x[iq];
			i = low;
			j = hi;
			while(i <= j)
				{
				while((x[i]<0 ? -x[i] : x[i]) < xk) i++;
			 	while((x[j]<0 ? -x[j] : x[j]) > xk) j--;
				if(i <= j)
					{
					temp = x[i];	x[i] = x[j];	x[j] = temp;
					i++;	j--;
					}
				}
			if(j < iq) 	low = i;
			if(i > iq)	hi  = j;
			}
		return (x[iq]<0 ? -x[iq] : x[iq]);
		}

       	public void sqrt(boolean PreserveNegative)
       		{
		int i;
		float hold;
		Notice("FltVec.sqrt: square root of " + vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			hold = vec[i];
			if (hold < 0F && PreserveNegative)
				vec[i] = -(float)(Math.sqrt(-hold));
			else if (hold < 0F)
				vec[i] = 0F;
			else
				vec[i] = (float)(Math.sqrt(hold));	
			}
		this.Amp0 = 0F;
		this.AmpFac = 1F;
		this.AmpUnits = new String("Square Root of " + this.AmpUnits);
		Noticeln("done.");
		}
	public void sqrt()
		{
		this.sqrt(false);
		}
	static void sqrtPanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "finds the square root of each element's amplitude.\n"
			+ "Negative amplitudes may be preserved by negating\n"
			+ "after finding the square root of the absolute value,\n"
			+ "else zero is rendered.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.cb0 = new Checkbox("Preserve negative values?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(false);
		}
	public void dosqrt(ViewmatAction vad)
		{
		this.sqrt(vad.cb0.getState());
		}
		
       	public void square(boolean PreserveNegative)
       		{
		int i;
		float hold;
		Notice("FltVec.square: squaring " + vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			hold = vec[i];
			vec[i] *= hold;
			if (hold < 0F && PreserveNegative)
				vec[i] = -vec[i];
			}
		this.Amp0 = 0F;
		this.AmpFac = 1F;
		this.AmpUnits = new String("Squared " + this.AmpUnits);
		Noticeln("done.");
		}
	public void square()
		{
		this.square(false);
		}
	static void squarePanel(ViewmatAction vad, ViewmatFrame f,
		boolean inplace, String label)
		{
		vad.expl = new TextArea(label + " of " + f.getTitle()
			+ (inplace ? " in-place\n" : " in new window\n")
			+ "\n"
			+ "The " + label + " method on class FltVec data\n"
			+ "finds the square of each element's amplitude.\n"
			+ "Negative amplitudes may be preserved by negating after squaring.",
			5, 35);
		vad.pp.add(vad.expl);
		vad.cb0 = new Checkbox("Preserve negative values?");
		vad.pp.add(vad.cb0);
		vad.cb0.setState(false);
		}
	public void dosquare(ViewmatAction vad)
		{
		this.square(vad.cb0.getState());
		}
	public void xcor(int e0, int ne, FltVec fv, int xe0, int xne)
		{
		for (int n=e0; n < e0+ne; n++)
			{
			this.vec[n] = this.vec[n] * fv.vec[xe0];
			for (int k=1; k<xne && (n+k)<(e0+ne); k++)
				this.vec[n] += this.vec[n+k] * fv.vec[xe0+k];
			}
		}
	public void autocor(int e0, int ne)
		{
		float tvec[] = new float[ne];
		for (int n=0; n < ne; n++)
			tvec[n] = this.vec[e0+n];
		for (int n=0; n < ne; n++)
			{
			this.vec[e0+n] = tvec[n] * tvec[n];
			for (int k=1; k<ne && (n+k)<ne; k++)
				this.vec[e0+n] += tvec[n+k] * tvec[k];
			}
		tvec = null;
		}
		
	public void makeIntImage
	(int[] Array, RgRGB[] ColorTable, boolean PositiveOnly, float Clip)
		{
		int i, index;
		float pclip, val;
		if (Clip < 0)
			Clip = this.max();
		pclip = PositiveOnly ? Clip : 2.0F*Clip;
		if (pclip == 0.0F)
			pclip = 1.0F;
		/*
		Notice("makeIntImage: making image of "
			+ vec.length + " elements, with PositiveOnly="
			+ PositiveOnly + " and Clip=" + Clip + "... ");
		*/
		for (i=0; i<vec.length; i++)
			{
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			val += (PositiveOnly ? 0.0F : Clip);
			if (val > 0F)
				index = (int)(254*val/pclip) + 1;
			else
				index = 0;
			if (index > 255)
				index = 255;
			else if (index < 0)
				index = 0;
			Array[i] =  (255 << 24)  | (ColorTable[index].R << 16)
				| (ColorTable[index].G << 8)
				| ColorTable[index].B;
			}
		/*
		Noticeln("done.");
		*/
		}
		
	public float max()
		{
		int i;
		float max, val;
		max = 0.0F;
		Notice("max: finding maximum value of "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			/*val = Math.abs(vec[i]);*/
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			val = val < 0.0F ? -val : val;
			if (val > max)
				max = val;
			}
		Noticeln("done.");
		return max;
		}
	
	public float min()
		{
		int i;
		float min, val;
		Notice("min: finding minimum absolute value of "
			+ vec.length + " elements... ");
		min = vec[0] < 0.0F ? -vec[0] : vec[0];
		for (i=1; i<vec.length; i++)
			{
			/*val = Math.abs(vec[i]);*/
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			val = val < 0.0F ? -val : val;
			if (val < min)
				min = val;
			}
		Noticeln("done.");
		return min;
		}
	
	public float smin()
		{
		int i;
		float min, val;
		Notice("smin: finding minimum signed value of "
			+ vec.length + " elements... ");
		min = vec[0];
		for (i=1; i<vec.length; i++)
			{
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			if (val < min)
				min = val;
			}
		Noticeln("done.");
		return min;
		}
	
	public float rms()
		{
		int i;
		float rms, val;
		rms = 0.0F;
		Notice("rms: finding root-mean-squared value of "
			+ vec.length + " elements... ");
		for (i=0; i<vec.length; i++)
			{
			val = vec[i];
			if (Float.isNaN(val))
				val = 0F;
			rms += val*val;
			}
		rms /= vec.length;
		Noticeln("done.");
		return ((float)(Math.sqrt((double)(rms))));
		}
	
	public void readBinaryFile(String name, int SkipBytes)
		{
		readBinaryFile(name, SkipBytes, 0);
		}
	public void readBinaryFile(String name, int SkipBytes, int readtype)
		{
		int i, bytes;
		int b1, b2, b3, b4;
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		DataInputStream dis = null;
		String tstr;
		switch (readtype)
			{
			case 3: tstr = " 32-bit integer"; break;
			case 4: tstr = " 32-bit Intel integer"; break;
			case 5: tstr = " 16-bit integer"; break;
			case 6: tstr = " 16-bit Intel integer"; break;
			case 7: tstr = " 8-bit integer"; break;
			case 8: tstr = " plain ascii text"; break;
			case 9: tstr = " 16-bit unsigned int"; break;
			case 10: tstr = " 8-bit unsigned int"; break;
			case 11: tstr = " 32-bit Intel Float"; break;
			default: tstr = " raw IEEE float"; break;
			}
		Notice("readBinaryFile: reading " + vec.length
			+ tstr
			/*(readtype>2 ?
				(readtype>3 ?
					(readtype>4 ?
						(readtype>5 ?
							(readtype>6 ?
								(readtype>7 ?
									" plain ascii text" : " 8-bit integer")
								: " 16-bit Intel integer")
							: " 16-bit integer")
						: " 32-bit Intel integer")
				: " 32-bit integer")
			: " raw IEEE float")*/
			+ " elements from file " + name + " after skipping " + SkipBytes +
			" bytes... ");
		if (readtype == 8)
			{
			bytes = readASCIIFile(name, (long)(SkipBytes));
			return;
			}
		try {fis = new FileInputStream(name); }
		catch(FileNotFoundException fnf)
			{
			Errout(fnf.toString());
			return;
			}
		bis = new BufferedInputStream(fis);
		dis = new DataInputStream(bis);
		if (SkipBytes > 0)
			{
			try {bytes = dis.skipBytes(SkipBytes); }
			catch(IOException ioe)
				{
				Errout("Could not seek " + SkipBytes
				+ " bytes into file " + name);
				return;
				}
			}
		if (readtype == 3)
			{
			for (i=0; i<vec.length; i++)
				{
				try {vec[i] = (float)(dis.readInt()); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 4)
			{
			for (i=0; i<vec.length; i++)
				{
				try
					{
					vec[i] = (float)(FltVec.readIntelInt(dis));
					}
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 5)
			{
			for (i=0; i<vec.length; i++)
				{
				try { vec[i] = (float)(dis.readShort()); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length/2) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 6)
			{
			for (i=0; i<vec.length; i++)
				{
				try
					{
					b1 = (int)(dis.readByte());
					b2 = (int)(dis.readByte());
					vec[i] = (float)((b2 << 8) + b1);
					}
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length/2) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 7)
			{
			for (i=0; i<vec.length; i++)
				{
				try { vec[i] = (float)(dis.readByte()); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (vec.length) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 9)
			{
			for (i=0; i<vec.length; i++)
				{
				try { vec[i] = (float)(dis.readUnsignedShort()); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length/2) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 10)
			{
			for (i=0; i<vec.length; i++)
				{
				try { vec[i] = (float)(dis.readUnsignedByte()); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (vec.length) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else if (readtype == 11)
			{
			for (i=0; i<vec.length; i++)
				{
				try
					{
					vec[i] = FltVec.readIntelFloat(dis);
					}
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		else
			{
			for (i=0; i<vec.length; i++)
				{
				try {vec[i] = dis.readFloat(); }
				catch(IOException ioe)
					{
					Errout("Could not read "
					+ (SEGYFLOATBYTES*vec.length) + " bytes from file "
					+ name);
					return;
					}
				}
			}
		try {fis.close(); }
		catch(IOException ioe)
			{
			Errout(ioe.toString());
			return;
			}
		Noticeln("done.");
		}

	public void createBinaryFile(String name)
		{
		int i, bytes;
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		DataOutputStream dos = null;
		Notice("createBinaryFile: writing " + vec.length
			+ " elements to file " + name + "... ");
		try {fos = new FileOutputStream(name); }
		catch(IOException ioe)
			{
			Errout("Can't create file " + name);
			Errout(ioe.toString());
			return;
			}
		bos = new BufferedOutputStream(fos);
		dos = new DataOutputStream(bos);
		for (i=0; i<vec.length; i++)
			{
			try {dos.writeFloat(vec[i]); }
			catch(IOException ioe)
				{
				Errout("Could not write "
				+ (SEGYFLOATBYTES*vec.length) + " bytes to file "
				+ name);
				return;
				}
			}
		try
			{
			dos.flush();
			bos.flush();
			fos.close();
			}
		catch(IOException ioe)
			{
			Errout(ioe.toString());
			return;
			}
		Noticeln("done.");
		}
	
	public void appendBinaryFile(String name)
		{
		int i;
		RandomAccessFile raf = null;
		Notice("appendBinaryFile: appending " + vec.length
			+ " elements to file " + name + "... ");
		try
			{
			raf = new RandomAccessFile(name, "rw");
			raf.seek(raf.length());
			}
		catch(Exception e)
			{
			Errout("Could not seek end of file " + name);
			Errout(e.toString());
			return;
			}
		ByteArrayOutputStream baos =
			new ByteArrayOutputStream(vec.length*SEGYFLOATBYTES);
		DataOutputStream dos = new DataOutputStream(baos);
		try
			{
			for (i=0; i<vec.length; i++)
				dos.writeFloat(vec[i]);
			dos.flush();
			}
		catch(IOException ioe)
			{
			Errout("Could not buffer "
			+ (SEGYFLOATBYTES*vec.length)
			+ " bytes prior to writing file " + name);
			Errout(ioe.toString());
			return;
			}
		try
			{
			raf.write(baos.toByteArray(), 0, vec.length*SEGYFLOATBYTES);
			raf.close();
			}
		catch(Exception e)
			{
			Errout("Could not append "
			+ (SEGYFLOATBYTES*vec.length) + " bytes to file " + name);
			Errout(e.toString());
			return;
			}
		Noticeln("done.");
		}
	
	public int readASCIIFile(String path, long skip)
		{
		FileReader fr;
		int i=0;
		try {fr = new FileReader(path); }
		catch(FileNotFoundException fnf)
			{
			Noticeln("Can't find ascii data file " + path);
			return -1;
			}
		Noticeln("readASCIIFile: reading " + vec.length
			+ " data values from ascii file\n\t" + path + " ...");
		String temp = "";
		BufferedReader in;
		StringTokenizer st;
		try
			{
			in = new BufferedReader(fr);
			if (skip > 0)
				in.skip(skip);
			for (i=0; i<vec.length && temp != null; )
				{
				temp = in.readLine();
				if (temp != null)
					{
					st = new StringTokenizer(temp);
					while (st.hasMoreTokens())
						{
						try
							{
							vec[i] = Float.valueOf(st.nextToken()).floatValue();
							i++;
							}
						catch (NumberFormatException nfe)
							{
							i--;
							continue;
							}
						}
					}
				}
 			}
		catch(IOException ioe)
			{
			Noticeln("Can't read geometry file " + path + "; found "
				+ i + " data values.");
			return i;
			}
		if (i != vec.length)
			{
			Noticeln("Expected " + vec.length + " but read "
				+ i + " data values from ascii file\n\t" + path);
			return i;
			}
		try
			{
			in.close();
			fr.close();
			}
		catch(IOException ioe)
			{
			Noticeln("Can't close ascii data file " + path + " after reading.");
			}
		Noticeln("Done.");
		return i;
		}
	public void writeASCII(OutputStream out)
		{
		int i;
		PrintStream p = new PrintStream(out);
		Noticeln("writeASCII: writing " + vec.length
			+ " elements to ascii output... ");
		for (i=0; i<vec.length; i++)
			{
			p.println(Viewmat.getSignif("" + vec[i], 12));
			/*
			if ((i+1)%5 == 0)
				p.println(Viewmat.getSignif("" + vec[i], 12));
			else
				p.print(Viewmat.getSignif("" + vec[i], 12) + " ");
			*/
			}
		p.flush();
		Noticeln("done.");
		}
	
	public void setElem(int Elem, float val)
		{
		this.vec[Elem] = val;
		}
	public float getElem(int Elem)
		{
		return this.vec[Elem];
		}
	public void windowof(FltVec fv, int e0, int de)
		{
		int i;
		Notice("windowof: windowing " + vec.length
			+ " elements from array of " + fv.vec.length
			+ ", e0=" + e0 + " de=" + de + "... ");
		for (i=0; i<this.vec.length; i++)
			this.vec[i] = fv.vec[e0+(i*de)];
		this.AmpUnits = new String(fv.AmpUnits);
		this.Amp0 = fv.Amp0;
		this.AmpFac = fv.AmpFac;
		this.ElemUnits = new String(fv.ElemUnits);
		this.Elem0 = fv.Elem0 + fv.DElem*e0;
		this.DElem = fv.DElem*de;
		Noticeln("done.");
		}
	public void windowof(FltPlane fp, int v0, int e0, int de)
		{
		int i;
		Notice("windowof: windowing " + vec.length
			+ " elements from vector " + v0 + ", of "
			+ fp.ne + "elements, from plane with e0=" + e0
			+ " de=" + de + "... ");
		for (i=0; i<this.vec.length; i++)
			this.vec[i] = fp.vec[(fp.ne*v0) + (e0+(i*de))];
		this.AmpUnits = new String(fp.AmpUnits);
		this.Amp0 = fp.Amp0;
		this.AmpFac = fp.AmpFac;
		this.ElemUnits = new String(fp.ElemUnits);
		this.Elem0 = fp.Elem0 + fp.DElem*e0;
		this.DElem = fp.DElem*de;
		Noticeln("done.");
		}
	public void tileto(FltPlane fp, int v0, int e0, int de)
		{
		int i;
		Notice("tileto: copying " + vec.length
			+ " elements into vector " + v0 + ", of "
			+ fp.ne + "elements, to plane with e0=" + e0
			+ " de=" + de + "... ");
		for (i=0; i<this.vec.length; i++)
			fp.vec[(fp.ne*v0) + (e0+(i*de))] = this.vec[i];
		Noticeln("done.");
		}
	public void windowof(FltVol fvol, int p0, int v0, int e0, int de)
		{
		int i;
		Notice("windowof: windowing " + vec.length
			+ " elements from vector " + v0 + ", of "
			+ fvol.ne + " elements, from plane " + p0
			+ " of volume, with e0=" + e0
			+ " de=" + de + "... ");
		for (i=0; i<this.vec.length; i++)
			this.vec[i] = fvol.vec[(fvol.nv*fvol.ne*p0)
					+ (fvol.ne*v0) + (e0+(i*de))];
		this.AmpUnits = new String(fvol.AmpUnits);
		this.Amp0 = fvol.Amp0;
		this.AmpFac = fvol.AmpFac;
		this.ElemUnits = new String(fvol.ElemUnits);
		this.Elem0 = fvol.Elem0 + fvol.DElem*e0;
		this.DElem = fvol.DElem*de;
		Noticeln("done.");
		}
	
	/* Constructors */
	FltVec(int NElem)
		{
		vec = new float[NElem];
		this.NDims = 1;
		this.AmpUnits = new String("Amplitude");
		this.ElemUnits = new String("Element");
		this.Amp0 = 0F;
		this.AmpFac = 1F;
		this.Elem0 = 0F;
		this.DElem = 1F;
		this.f = null;
		this.noticeon = true;
		}
	/* Construct a copy */
	FltVec(FltVec fv) 
		{
		this.vec = new float[fv.vec.length];
		System.arraycopy(fv.vec, 0, this.vec, 0, fv.vec.length);
		this.NDims = fv.NDims;
		this.AmpUnits = new String(fv.AmpUnits);
		this.ElemUnits = new String(fv.ElemUnits);
		this.Amp0 = fv.Amp0;
		this.AmpFac = fv.AmpFac;
		this.Elem0 = fv.Elem0;
		this.DElem = fv.DElem;
		this.f = fv.f;
		this.noticeon = fv.noticeon;
		}
	/* Construct a "cast" by referencing but not copying the array data */
	FltVec(FltVec fv, float vec[]) 
		{
		this.vec = vec;
		this.NDims = 1;
		this.AmpUnits = fv.AmpUnits;
		this.ElemUnits = fv.ElemUnits;
		this.Amp0 = fv.Amp0;
		this.AmpFac = fv.AmpFac;
		this.Elem0 = fv.Elem0;
		this.DElem = fv.DElem;
		this.f = fv.f;
		this.noticeon = fv.noticeon;
		}
	/* Copy FltVec data values but not float[] vector data to this */
	public void copyvals(FltVec fv)
		{
		this.NDims = fv.NDims;
		this.AmpUnits = new String(fv.AmpUnits);
		this.ElemUnits = new String(fv.ElemUnits);
		this.Amp0 = fv.Amp0;
		this.AmpFac = fv.AmpFac;
		this.Elem0 = fv.Elem0;
		this.DElem = fv.DElem;
		this.f = fv.f;
		this.noticeon = fv.noticeon;
		}
	/* Copy FltVec float[] vector data but not data field values to this */
	public void copyvec(FltVec fv)
		{
		System.arraycopy(fv.vec, 0, this.vec, 0, fv.vec.length);
		}
	
	/* RGData interface methods */
	public int getNDims()
		{ return NDims; }
	public int getNMembofDim(int Dim)
		{
		if (Dim == 0)
			return vec.length;
		else if (Dim >= NDims)
			return 1;
		else
			return 0;
		}
	public String getAmpUnits()
		{
		return AmpUnits;		
		}
	public void setAmpUnits(String Ampunits)
		{
		AmpUnits = new String(Ampunits);
		}
	public float getAmp0()
		{
		return Amp0;		
		}
	public void setAmp0(float Amp0)
		{
		this.Amp0 = Amp0;
		}
	public float getAmpFac()
		{
		return AmpFac;		
		}
	public void setAmpFac(float Ampfac)
		{
		this.AmpFac = Ampfac;
		}
	public String getUnitsofDim(int Dim)
		{
		if (Dim == 0)
			return ElemUnits;
		return "";
		}
	public void setUnitsofDim(int Dim, String Dimunits)
		{
		if (Dim == 0)
			ElemUnits = new String(Dimunits);
		}
	public float getUnit0ofDim(int Dim)
		{
		if (Dim == 0)
			return Elem0;
		return 0F;
		}
	public void setUnit0ofDim(int Dim, float Unit0)
		{
		if (Dim == 0)
			Elem0 = Unit0;
		}
	public float getDUnitofDim(int Dim)
		{
		if (Dim == 0)
			return DElem;
		return 1F;
		}
	public void setDUnitofDim(int Dim, float DUnit)
		{
		if (Dim == 0)
			DElem = DUnit;
		}
	public void Errout(String Error)
		{
		System.out.println();
		System.out.println(Error);
		System.out.println();
		System.out.flush();
		if (this.f != null)
			{
			ViewmatNotice vn = new ViewmatNotice(this.f,
			"Error on " + this.f.getTitle(), Error);
			vn.show();
			}
		}
	public void Noticeln(String Note)
		{
		if (noticeon)
			{
			System.out.println(Note);
			System.out.flush();
			}
		}
	public void Notice(String Note)
		{
		if (noticeon)
			{
			System.out.print(Note);
			System.out.flush();
			}
		}
	public void setNoticeOn(boolean on)
		{
		this.noticeon = on;
		}
	}