View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.math;
18  
19  import org.apache.commons.math.linear.ArrayRealVector;
20  
21  /**
22   * Exception thrown when an error occurs evaluating a function.
23   * <p>
24   * Maintains an <code>argument</code> property holding the input value that
25   * caused the function evaluation to fail.
26   * 
27   * @version $Revision: 783702 $ $Date: 2009-06-11 04:54:02 -0400 (Thu, 11 Jun 2009) $
28   */
29  public class FunctionEvaluationException extends MathException  {
30      
31      /** Serializable version identifier. */
32      private static final long serialVersionUID = -4305020489115478365L;
33  
34      /** Argument causing function evaluation failure */
35      private double[] argument;
36      
37      /**
38       * Construct an exception indicating the argument value
39       * that caused the function evaluation to fail.
40       * 
41       * @param argument  the failing function argument 
42       */
43      public FunctionEvaluationException(double argument) {
44          super("evaluation failed for argument = {0}", argument);
45          this.argument = new double[] { argument };
46      }
47      
48      /**
49       * Construct an exception indicating the argument value
50       * that caused the function evaluation to fail.
51       * 
52       * @param argument  the failing function argument 
53       * @since 2.0
54       */
55      public FunctionEvaluationException(double[] argument) {
56          super("evaluation failed for argument = {0}", new ArrayRealVector(argument));
57          this.argument = argument.clone();
58      }
59      
60      /**
61       * Constructs an exception with specified formatted detail message.
62       * Message formatting is delegated to {@link java.text.MessageFormat}.
63       * @param argument  the failing function argument 
64       * @param pattern format specifier
65       * @param arguments format arguments
66       * @since 1.2
67       */
68      public FunctionEvaluationException(double argument,
69                                         String pattern, Object ... arguments) {
70          super(pattern, arguments);
71          this.argument = new double[] { argument };
72      }
73  
74      /**
75       * Constructs an exception with specified formatted detail message.
76       * Message formatting is delegated to {@link java.text.MessageFormat}.
77       * @param argument  the failing function argument 
78       * @param pattern format specifier
79       * @param arguments format arguments
80       * @since 2.0
81       */
82      public FunctionEvaluationException(double[] argument,
83                                         String pattern, Object ... arguments) {
84          super(pattern, arguments);
85          this.argument = argument.clone();
86      }
87  
88      /**
89       * Constructs an exception with specified root cause.
90       * Message formatting is delegated to {@link java.text.MessageFormat}.
91       * @param cause  the exception or error that caused this exception to be thrown
92       * @param argument  the failing function argument 
93       * @since 1.2
94       */
95      public FunctionEvaluationException(Throwable cause, double argument) {
96          super(cause);
97          this.argument = new double[] { argument };
98      }
99  
100     /**
101      * Constructs an exception with specified root cause.
102      * Message formatting is delegated to {@link java.text.MessageFormat}.
103      * @param cause  the exception or error that caused this exception to be thrown
104      * @param argument  the failing function argument 
105      * @since 2.0
106      */
107     public FunctionEvaluationException(Throwable cause, double[] argument) {
108         super(cause);
109         this.argument = argument.clone();
110     }
111 
112     /**
113      * Constructs an exception with specified formatted detail message and root cause.
114      * Message formatting is delegated to {@link java.text.MessageFormat}.
115      * @param cause  the exception or error that caused this exception to be thrown
116      * @param argument  the failing function argument 
117      * @param pattern format specifier
118      * @param arguments format arguments
119      * @since 1.2
120      */
121     public FunctionEvaluationException(Throwable cause,
122                                        double argument, String pattern,
123                                        Object ... arguments) {
124         super(cause, pattern, arguments);
125         this.argument = new double[] { argument };
126     }
127 
128     /**
129      * Constructs an exception with specified formatted detail message and root cause.
130      * Message formatting is delegated to {@link java.text.MessageFormat}.
131      * @param cause  the exception or error that caused this exception to be thrown
132      * @param argument  the failing function argument 
133      * @param pattern format specifier
134      * @param arguments format arguments
135      * @since 2.0
136      */
137     public FunctionEvaluationException(Throwable cause,
138                                        double[] argument, String pattern,
139                                        Object ... arguments) {
140         super(cause, pattern, arguments);
141         this.argument = argument.clone();
142     }
143 
144     /**
145      * Returns the function argument that caused this exception.
146      * 
147      * @return  argument that caused function evaluation to fail
148      */
149     public double[] getArgument() {
150         return argument.clone();
151     }
152 
153 }