**Inheritance:**
java.lang.Object
```
public final class EquationMathematicalOperatorType
```

Mathematical Operators Type
## Fields

| Field | Description |
| --- | --- |
| [ANTICLOCKWISE_CONTOUR_INTEGRAL](#ANTICLOCKWISE-CONTOUR-INTEGRAL) | "\\u922d? |
| [CLOCKWISE](#CLOCKWISE) | "\\u922d? |
| [CLOCKWISE_CONTOUR_INTEGRAL](#CLOCKWISE-CONTOUR-INTEGRAL) | "\\u922d? |
| [COMPLEMENT](#COMPLEMENT) | "\\u922d? |
| [CONTAIN](#CONTAIN) | "\\u922d? |
| [CONTOUR_INTEGRAL](#CONTOUR-INTEGRAL) | "\\u922d? |
| [DOUBLE_INTEGRAL](#DOUBLE-INTEGRAL) | "\\u922d? |
| [ELEMENT_OF](#ELEMENT-OF) | "\\u922d? |
| [EMPTY_SET](#EMPTY-SET) | "\\u922d? |
| [END_OF_PROOF](#END-OF-PROOF) | "\\u922d? |
| [EXISTS](#EXISTS) | "\\u922d? |
| [FOR_ALL](#FOR-ALL) | "\\u922d\\u20ac" Unicode:\\u2200 |
| [INCREMENT](#INCREMENT) | "\\u922d? |
| [INTEGRAL](#INTEGRAL) | "\\u922d? |
| [INTERSECTION](#INTERSECTION) | "\\u922d? |
| [LOGICAL_AND](#LOGICAL-AND) | "\\u922d? |
| [LOGICAL_OR](#LOGICAL-OR) | "\\u922d? |
| [NABLA](#NABLA) | "\\u922d? |
| [NARY_COPRODUCT](#NARY-COPRODUCT) | "\\u922d? |
| [NARY_INTERSECTION](#NARY-INTERSECTION) | "\\u9230? |
| [NARY_LOGICAL_AND](#NARY-LOGICAL-AND) | "\\u9230\\u20ac" Unicode:\\u22c0 |
| [NARY_LOGICAL_OR](#NARY-LOGICAL-OR) | "\\u9230? |
| [NARY_PRODUCT](#NARY-PRODUCT) | "\\u922d? |
| [NARY_SUMMATION](#NARY-SUMMATION) | "\\u922d? |
| [NARY_UNION](#NARY-UNION) | "\\u9230? |
| [NOT_AN_ELEMENT_OF](#NOT-AN-ELEMENT-OF) | "\\u922d? |
| [NOT_CONTAIN](#NOT-CONTAIN) | "\\u922d? |
| [NOT_EXISTS](#NOT-EXISTS) | "\\u922d? |
| [PARTIAL_DIFFERENTIAL](#PARTIAL-DIFFERENTIAL) | "\\u922d? |
| [SMALL_CONTAIN](#SMALL-CONTAIN) | "\\u922d? |
| [SMALL_ELEMENT_OF](#SMALL-ELEMENT-OF) | "\\u922d? |
| [SURFACE_INTEGRAL](#SURFACE-INTEGRAL) | "\\u922d? |
| [TRIPLE_INTEGRAL](#TRIPLE-INTEGRAL) | "\\u922d? |
| [UNION](#UNION) | "\\u922d? |
| [UNKNOWN](#UNKNOWN) | Use unknown type when not found in existing type. |
| [VOLUME_INTEGRAL](#VOLUME-INTEGRAL) | "\\u922d? |
## Methods

| Method | Description |
| --- | --- |
| [equals(Object arg0)](#equals-java.lang.Object-) |  |
| [getClass()](#getClass--) |  |
| [hashCode()](#hashCode--) |  |
| [notify()](#notify--) |  |
| [notifyAll()](#notifyAll--) |  |
| [toString()](#toString--) |  |
| [wait()](#wait--) |  |
| [wait(long arg0)](#wait-long-) |  |
| [wait(long arg0, int arg1)](#wait-long-int-) |  |
### ANTICLOCKWISE_CONTOUR_INTEGRAL {#ANTICLOCKWISE-CONTOUR-INTEGRAL}
```
public static final int ANTICLOCKWISE_CONTOUR_INTEGRAL
```


"\\u922d? Unicode:\\u2233

### CLOCKWISE {#CLOCKWISE}
```
public static final int CLOCKWISE
```


"\\u922d? Unicode:\\u2231

### CLOCKWISE_CONTOUR_INTEGRAL {#CLOCKWISE-CONTOUR-INTEGRAL}
```
public static final int CLOCKWISE_CONTOUR_INTEGRAL
```


"\\u922d? Unicode:\\u2232

### COMPLEMENT {#COMPLEMENT}
```
public static final int COMPLEMENT
```


"\\u922d? Unicode:\\u2201

### CONTAIN {#CONTAIN}
```
public static final int CONTAIN
```


"\\u922d? Unicode:\\u220b

### CONTOUR_INTEGRAL {#CONTOUR-INTEGRAL}
```
public static final int CONTOUR_INTEGRAL
```


"\\u922d? Unicode:\\u222e

### DOUBLE_INTEGRAL {#DOUBLE-INTEGRAL}
```
public static final int DOUBLE_INTEGRAL
```


"\\u922d? Unicode:\\u222c

### ELEMENT_OF {#ELEMENT-OF}
```
public static final int ELEMENT_OF
```


"\\u922d? Unicode:\\u2208

### EMPTY_SET {#EMPTY-SET}
```
public static final int EMPTY_SET
```


"\\u922d? Unicode:\\u2205

### END_OF_PROOF {#END-OF-PROOF}
```
public static final int END_OF_PROOF
```


"\\u922d? Unicode:\\u220e

### EXISTS {#EXISTS}
```
public static final int EXISTS
```


"\\u922d? Unicode:\\u2203

### FOR_ALL {#FOR-ALL}
```
public static final int FOR_ALL
```


"\\u922d\\u20ac" Unicode:\\u2200

### INCREMENT {#INCREMENT}
```
public static final int INCREMENT
```


"\\u922d? Unicode:\\u2206

### INTEGRAL {#INTEGRAL}
```
public static final int INTEGRAL
```


"\\u922d? Unicode:\\u222b

### INTERSECTION {#INTERSECTION}
```
public static final int INTERSECTION
```


"\\u922d? Unicode:\\u2229

### LOGICAL_AND {#LOGICAL-AND}
```
public static final int LOGICAL_AND
```


"\\u922d? Unicode:\\u2227

### LOGICAL_OR {#LOGICAL-OR}
```
public static final int LOGICAL_OR
```


"\\u922d? Unicode:\\u2228

### NABLA {#NABLA}
```
public static final int NABLA
```


"\\u922d? Unicode:\\u2207

### NARY_COPRODUCT {#NARY-COPRODUCT}
```
public static final int NARY_COPRODUCT
```


"\\u922d? Unicode:\\u2210

### NARY_INTERSECTION {#NARY-INTERSECTION}
```
public static final int NARY_INTERSECTION
```


"\\u9230? Unicode:\\u22c2

### NARY_LOGICAL_AND {#NARY-LOGICAL-AND}
```
public static final int NARY_LOGICAL_AND
```


"\\u9230\\u20ac" Unicode:\\u22c0

### NARY_LOGICAL_OR {#NARY-LOGICAL-OR}
```
public static final int NARY_LOGICAL_OR
```


"\\u9230? Unicode:\\u22c1

### NARY_PRODUCT {#NARY-PRODUCT}
```
public static final int NARY_PRODUCT
```


"\\u922d? Unicode:\\u220f

### NARY_SUMMATION {#NARY-SUMMATION}
```
public static final int NARY_SUMMATION
```


"\\u922d? Unicode:\\u2211

### NARY_UNION {#NARY-UNION}
```
public static final int NARY_UNION
```


"\\u9230? Unicode:\\u22c3

### NOT_AN_ELEMENT_OF {#NOT-AN-ELEMENT-OF}
```
public static final int NOT_AN_ELEMENT_OF
```


"\\u922d? Unicode:\\u2209

### NOT_CONTAIN {#NOT-CONTAIN}
```
public static final int NOT_CONTAIN
```


"\\u922d? Unicode:\\u220c

### NOT_EXISTS {#NOT-EXISTS}
```
public static final int NOT_EXISTS
```


"\\u922d? Unicode:\\u2204

### PARTIAL_DIFFERENTIAL {#PARTIAL-DIFFERENTIAL}
```
public static final int PARTIAL_DIFFERENTIAL
```


"\\u922d? Unicode:\\u2202

### SMALL_CONTAIN {#SMALL-CONTAIN}
```
public static final int SMALL_CONTAIN
```


"\\u922d? Unicode:\\u220d

### SMALL_ELEMENT_OF {#SMALL-ELEMENT-OF}
```
public static final int SMALL_ELEMENT_OF
```


"\\u922d? Unicode:\\u220a

### SURFACE_INTEGRAL {#SURFACE-INTEGRAL}
```
public static final int SURFACE_INTEGRAL
```


"\\u922d? Unicode:\\u222f

### TRIPLE_INTEGRAL {#TRIPLE-INTEGRAL}
```
public static final int TRIPLE_INTEGRAL
```


"\\u922d? Unicode:\\u222d

### UNION {#UNION}
```
public static final int UNION
```


"\\u922d? Unicode:\\u222a

### UNKNOWN {#UNKNOWN}
```
public static final int UNKNOWN
```


Use unknown type when not found in existing type.

### VOLUME_INTEGRAL {#VOLUME-INTEGRAL}
```
public static final int VOLUME_INTEGRAL
```


"\\u922d? Unicode:\\u2230

### equals(Object arg0) {#equals-java.lang.Object-}
```
public boolean equals(Object arg0)
```




**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| arg0 | java.lang.Object |  |

**Returns:**
boolean
### getClass() {#getClass--}
```
public final native Class<?> getClass()
```




**Returns:**
java.lang.Class<?>
### hashCode() {#hashCode--}
```
public native int hashCode()
```




**Returns:**
int
### notify() {#notify--}
```
public final native void notify()
```




### notifyAll() {#notifyAll--}
```
public final native void notifyAll()
```




### toString() {#toString--}
```
public String toString()
```




**Returns:**
java.lang.String
### wait() {#wait--}
```
public final void wait()
```




### wait(long arg0) {#wait-long-}
```
public final native void wait(long arg0)
```




**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| arg0 | long |  |

### wait(long arg0, int arg1) {#wait-long-int-}
```
public final void wait(long arg0, int arg1)
```




**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| arg0 | long |  |
| arg1 | int |  |