Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 Davor Sauer
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.jdice.calc;
 
 
Calculator extension with trigonometric functions

Author(s):
Davor Sauer <davor.sauer@gmail.com>
 
 public class CalcTrig extends AbstractCalculator<CalcTrigimplements
 
 	protected CalcTrig getThis() {
 		return this;
 	}
 
 	public CalcTrig() {
 		super();
 	}
 
 	// 1
 	public CalcTrig(short value) {
 		super(value);
 	}
 
 	// 2
 	public CalcTrig(int value) {
 		super(value);
 	}
 
 	// 3
 	public CalcTrig(long value) {
 		super(value);
 	}
 
 	// 4
 	public CalcTrig(float value) {
 		super(value);
 	}
 
	// 5
	public CalcTrig(double value) {
		super(value);
	}
	// 6
	public CalcTrig(Object value) {
		super(value);
	}
	// 7
	public CalcTrig(String value) {
		super(value);
	}
	// 7
	public CalcTrig(String valuechar decimalSeparator) {
		super(valuedecimalSeparator);
	}
	// 8
	public CalcTrig(Num value) {
		super(value);
	}
	//
	// Builder
	//
	public static CalcTrig builder() {
		CalcTrig calc = new CalcTrig();
		return calc;
	}
	public static CalcTrig builder(String equationthrows ParseException {
		CalcTrig calc = new CalcTrig();
		calc.parse(equation);
		return calc;
	}
	public static CalcTrig builder(String equationObject... values)
			throws ParseException {
		CalcTrig calc = new CalcTrig();
		calc.parse(equationvalues);
		return calc;
	}
	//
	// DEFAULT OPERATIONS
	//
	// -----------------
	public CalcTrig add() {
		return append(AddOperator.class);
	}
	// 1
	public CalcTrig add(short value) {
		return append(AddOperator.classvalue);
	}
	// 2
	public CalcTrig add(int value) {
		return append(AddOperator.classvalue);
	}
	// 3
	public CalcTrig add(long value) {
		return append(AddOperator.classvalue);
	}
	// 4
	public CalcTrig add(float value) {
		return append(AddOperator.classvalue);
	}
	// 5
	public CalcTrig add(double value) {
		return append(AddOperator.classvalue);
	}
	// 6
	public CalcTrig add(Object value) {
		return append(AddOperator.classvalue);
	}
	// 7
	public CalcTrig add(String value) {
		return append(AddOperator.classvalue);
	}
	// 7
	public CalcTrig add(String valuechar decimalSeparator) {
		return append(AddOperator.classvaluedecimalSeparator);
	}
	// 8
	public CalcTrig add(Num value) {
		return append(AddOperator.classvalue);
	}
	// -----------------
	public CalcTrig subtract() {
		return append(SubOperator.class);
	}
	// 1
	public CalcTrig sub(short value) {
		return append(SubOperator.classvalue);
	}
	// 2
	public CalcTrig sub(int value) {
		return append(SubOperator.classvalue);
	}
	// 3
	public CalcTrig sub(long value) {
		return append(SubOperator.classvalue);
	}
	// 4
	public CalcTrig sub(float value) {
		return append(SubOperator.classvalue);
	}
	// 5
	public CalcTrig sub(double value) {
		return append(SubOperator.classvalue);
	}
	// 6
	public CalcTrig sub(Object value) {
		return append(SubOperator.classvalue);
	}
	// 7
	public CalcTrig sub(String value) {
		return append(SubOperator.classvalue);
	}
	// 7
	public CalcTrig sub(String valuechar decimalSeparator) {
		return append(SubOperator.classvaluedecimalSeparator);
	}
	// 8
	public CalcTrig sub(Num value) {
		return append(SubOperator.classvalue);
	}
	// -----------------
	public CalcTrig divide() {
		return append(DivOperator.class);
	}
	// 1
	public CalcTrig div(short value) {
		return append(DivOperator.classvalue);
	}
	// 2
	public CalcTrig div(int value) {
		return append(DivOperator.classvalue);
	}
	// 3
	public CalcTrig div(long value) {
		return append(DivOperator.classvalue);
	}
	// 4
	public CalcTrig div(float value) {
		return append(DivOperator.classvalue);
	}
	// 5
	public CalcTrig div(double value) {
		return append(DivOperator.classvalue);
	}
	// 6
	public CalcTrig div(Object value) {
		return append(DivOperator.classvalue);
	}
	// 7
	public CalcTrig div(String value) {
		return append(DivOperator.classvalue);
	}
	// 7
	public CalcTrig div(String valuechar decimalSeparator) {
		return append(DivOperator.classvaluedecimalSeparator);
	}
	// 8
	public CalcTrig div(Num value) {
		return append(DivOperator.classvalue);
	}
	// -----------------
	public CalcTrig multiply() {
		return append(MulOperator.class);
	}
	// 1
	public CalcTrig mul(short value) {
		return append(MulOperator.classvalue);
	}
	// 2
	public CalcTrig mul(int value) {
		return append(MulOperator.classvalue);
	}
	// 3
	public CalcTrig mul(long value) {
		return append(MulOperator.classvalue);
	}
	// 4
	public CalcTrig mul(float value) {
		return append(MulOperator.classvalue);
	}
	// 5
	public CalcTrig mul(double value) {
		return append(MulOperator.classvalue);
	}
	// 6
	public CalcTrig mul(Object value) {
		return append(MulOperator.classvalue);
	}
	// 7
	public CalcTrig mul(String value) {
		return append(MulOperator.classvalue);
	}
	// 7
	public CalcTrig mul(String valuechar decimalSeparator) {
		return append(MulOperator.classvaluedecimalSeparator);
	}
	// 8
	public CalcTrig mul(Num value) {
		return append(MulOperator.classvalue);
	}
	// -----------------
	public CalcTrig power() {
		return append(PowOperator.class);
	}
	// 1
	public CalcTrig pow(short value) {
		return append(PowOperator.classvalue);
	}
	// 2
	public CalcTrig pow(int value) {
		return append(PowOperator.classvalue);
	}
	// 3
	public CalcTrig pow(long value) {
		return append(PowOperator.classvalue);
	}
	// 4
	public CalcTrig pow(float value) {
		return append(PowOperator.classvalue);
	}
	// 5
	public CalcTrig pow(double value) {
		return append(PowOperator.classvalue);
	}
	// 6
	public CalcTrig pow(Object value) {
		return append(PowOperator.classvalue);
	}
	// 7
	public CalcTrig pow(String value) {
		return append(PowOperator.classvalue);
	}
	// 7
	public CalcTrig pow(String valuechar decimalSeparator) {
		return append(PowOperator.classvaluedecimalSeparator);
	}
	// 8
	public CalcTrig pow(Num value) {
		return append(PowOperator.classvalue);
	}
	public CalcTrig abs(AbstractCalculator equation) {
		return append(AbsFunction.class);
	}
	public CalcTrig abs(short value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(int value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(long value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(float value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(double value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(Object value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(String value) {
		return append(AbsFunction.classnew Num(value));
	}
	public CalcTrig abs(String valuechar decimalSeparator) {
		return append(AbsFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig abs(Num value) {
		return append(AbsFunction.classvalue);
	}
	public CalcTrig sqrt(AbstractCalculator equation) {
		return append(SqrtFunction.classequation);
	}
	public CalcTrig sqrt(short value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(int value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(long value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(float value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(double value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(Object value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(String value) {
		return append(SqrtFunction.classnew Num(value));
	}
	public CalcTrig sqrt(String valuechar decimalSeparator) {
		return append(SqrtFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig sqrt(Num value) {
		return append(SqrtFunction.classvalue);
	}
	public CalcTrig modulo() {
		return append(ModOperator.class);
	}
	public CalcTrig mod(short value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(int value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(long value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(float value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(double value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(Object value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(String value) {
		return append(ModOperator.classvalue);
	}
	public CalcTrig mod(String valuechar decimalSeparator) {
		return append(ModOperator.classvaluedecimalSeparator);
	}
	public CalcTrig mod(Num value) {
		return append(ModOperator.classvalue);
	}
	//
	// OPERATIONS
	//
	public CalcTrig sin(AbstractCalculator equation) {
		return append(SinFunction.classequation);
	}
	public CalcTrig sin(Object value) {
		return append(SinFunction.classnew Num(value));
	}
	public CalcTrig sin(String value) {
		return append(SinFunction.classnew Num(value));
	}
	public CalcTrig sin(String valuechar decimalSeparator) {
		return append(SinFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig sin(Num value) {
		return append(SinFunction.classvalue);
	}
	public CalcTrig cos(AbstractCalculator equation) {
		return append(CosFunction.classequation);
	}
	public CalcTrig cos(Object value) {
		return append(CosFunction.classnew Num(value));
	}
	public CalcTrig cos(String value) {
		return append(CosFunction.classnew Num(value));
	}
	public CalcTrig cos(String valuechar decimalSeparator) {
		return append(CosFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig cos(Num value) {
		return append(CosFunction.classvalue);
	}
	public CalcTrig tan(AbstractCalculator equation) {
		return append(TanFunction.classequation);
	}
	public CalcTrig tan(Object value) {
		return append(TanFunction.classnew Num(value));
	}
	public CalcTrig tan(String value) {
		return append(TanFunction.classnew Num(value));
	}
	public CalcTrig tan(String valuechar decimalSeparator) {
		return append(TanFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig tan(Num value) {
		return append(TanFunction.classvalue);
	}
	public CalcTrig atan(AbstractCalculator equation) {
		return append(ArcTanFunction.classequation);
	}
	public CalcTrig atan(Object value) {
		return append(ArcTanFunction.classnew Num(value));
	}
	public CalcTrig atan(String value) {
		return append(ArcTanFunction.classnew Num(value));
	}
	public CalcTrig atan(String valuechar decimalSeparator) {
		return append(ArcTanFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig atan(Num value) {
		return append(ArcTanFunction.classvalue);
	}
	public CalcTrig acos(AbstractCalculator equation) {
		return append(ArcCosFunction.classequation);
	}
	public CalcTrig acos(Object value) {
		return append(ArcCosFunction.classnew Num(value));
	}
	public CalcTrig acos(String value) {
		return append(ArcCosFunction.classnew Num(value));
	}
	public CalcTrig acos(String valuechar decimalSeparator) {
		return append(ArcCosFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig acos(Num value) {
		return append(ArcCosFunction.classvalue);
	}
	public CalcTrig asin(AbstractCalculator equation) {
		return append(ArcSinFunction.classequation);
	}
	public CalcTrig asin(Object value) {
		return append(ArcSinFunction.classnew Num(value));
	}
	public CalcTrig asin(String value) {
		return append(ArcSinFunction.classnew Num(value));
	}
	public CalcTrig asin(String valuechar decimalSeparator) {
		return append(ArcSinFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig asin(Num value) {
		return append(ArcSinFunction.classvalue);
	}
	public CalcTrig tanh(AbstractCalculator equation) {
		return append(TanhFunction.classequation);
	}
	public CalcTrig tanh(Object value) {
		return append(TanhFunction.classnew Num(value));
	}
	public CalcTrig tanh(String value) {
		return append(TanhFunction.classnew Num(value));
	}
	public CalcTrig tanh(String valuechar decimalSeparator) {
		return append(TanhFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig tanh(Num value) {
		return append(TanhFunction.classvalue);
	}
	public CalcTrig cosh(AbstractCalculator equation) {
		return append(CoshFunction.classequation);
	}
	public CalcTrig cosh(Object value) {
		return append(CoshFunction.classnew Num(value));
	}
	public CalcTrig cosh(String value) {
		return append(CoshFunction.classnew Num(value));
	}
	public CalcTrig cosh(String valuechar decimalSeparator) {
		return append(CoshFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig cosh(Num value) {
		return append(CoshFunction.classvalue);
	}
	public CalcTrig sinh(AbstractCalculator equation) {
		return append(SinhFunction.classequation);
	}
	public CalcTrig sinh(Object value) {
		return append(SinhFunction.classnew Num(value));
	}
	public CalcTrig sinh(String value) {
		return append(SinhFunction.classnew Num(value));
	}
	public CalcTrig sinh(String valuechar decimalSeparator) {
		return append(SinhFunction.classnew Num(valuedecimalSeparator));
	}
	public CalcTrig sinh(Num value) {
		return append(SinhFunction.classvalue);
	}
	public CalcTrig log(AbstractCalculator equation) {
		return append(LogFunction.classequation);
	}
	public CalcTrig log(Object value) {
		return append(LogFunction.classvalue);
	}
	public CalcTrig log(String value) {
		return append(LogFunction.classvalue);
	}
	public CalcTrig log(String valuechar decimalSeparator) {
		return append(LogFunction.classvalue);
	}
	public CalcTrig log(Num value) {
		return append(LogFunction.classvalue);
	}
New to GrepCode? Check out our FAQ X